void bark_noise_hybridmp(int n, const long *b, const float *f, float *noise,
                         const float offset, const int fixed) {
  float *N = alloca(n * sizeof(*N));
  float *X = alloca(n * sizeof(*N));
  float *XX = alloca(n * sizeof(*N));
  float *Y = alloca(n * sizeof(*N));
  float *XY = alloca(n * sizeof(*N));
  float tN, tX, tXX, tY, tXY;
  int i;
  int lo, hi;
  float R, A, B, D;
  float w, x, y;
  tN = tX = tXX = tY = tXY = 0.f;
  y = f[0] + offset;
  if (y < 1.f)
    y = 1.f;
  w = y * y * .5;
  tN += w;
  tX += w;
  tY += w * y;
  N[0] = tN;
  X[0] = tX;
  XX[0] = tXX;
  Y[0] = tY;
  XY[0] = tXY;
  for (i = 1, x = 1.f; i < n; i++, x += 1.f) {
    y = f[i] + offset;
    if (y < 1.f)
      y = 1.f;
    w = y * y;
    tN += w;
    tX += w * x;
    tXX += w * x * x;
    tY += w * y;
    tXY += w * x * y;
    N[i] = tN;
    X[i] = tX;
    XX[i] = tXX;
    Y[i] = tY;
    XY[i] = tXY;
  }
  for (i = 0, x = 0.f;; i++, x += 1.f) {
    lo = b[i] >> 16;
    if (lo >= 0)
      break;
    hi = b[i] & 0xffff;
    tN = N[hi] + N[-lo];
    tX = X[hi] - X[-lo];
    tXX = XX[hi] + XX[-lo];
    tY = Y[hi] + Y[-lo];
    tXY = XY[hi] - XY[-lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R < 0.f)
      R = 0.f;
    noise[i] = R - offset;
  }
  for (;; i++, x += 1.f) {
    lo = b[i] >> 16;
    hi = b[i] & 0xffff;
    if (hi >= n)
      break;
    tN = N[hi] - N[lo];
    tX = X[hi] - X[lo];
    tXX = XX[hi] - XX[lo];
    tY = Y[hi] - Y[lo];
    tXY = XY[hi] - XY[lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R < 0.f)
      R = 0.f;
    noise[i] = R - offset;
  }
  for (; i < n; i++, x += 1.f) {
    R = (A + x * B) / D;
    if (R < 0.f)
      R = 0.f;
    noise[i] = R - offset;
  }
  if (fixed <= 0)
    return;
  for (i = 0, x = 0.f;; i++, x += 1.f) {
    hi = i + fixed / 2;
    lo = hi - fixed;
    if (lo >= 0)
      break;
    tN = N[hi] + N[-lo];
    tX = X[hi] - X[-lo];
    tXX = XX[hi] + XX[-lo];
    tY = Y[hi] + Y[-lo];
    tXY = XY[hi] - XY[-lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R - offset < noise[i])
      noise[i] = R - offset;
  }
  for (;; i++, x += 1.f) {
    hi = i + fixed / 2;
    lo = hi - fixed;
    if (hi >= n)
      break;
    tN = N[hi] - N[lo];
    tX = X[hi] - X[lo];
    tXX = XX[hi] - XX[lo];
    tY = Y[hi] - Y[lo];
    tXY = XY[hi] - XY[lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R - offset < noise[i])
      noise[i] = R - offset;
  }
  for (; i < n; i++, x += 1.f) {
    R = (A + x * B) / D;
    if (R - offset < noise[i])
      noise[i] = R - offset;
  }
}


x86 assembly (clang, -O0):
<bark_noise_hybridmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
movslq -0x4(%rbp),%rax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rax
sub    %rcx,%rax
mov    %rax,%rsp
mov    %rax,-0x30(%rbp)
movslq -0x4(%rbp),%rax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rax
sub    %rcx,%rax
mov    %rax,%rsp
mov    %rax,-0x38(%rbp)
movslq -0x4(%rbp),%rax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rax
sub    %rcx,%rax
mov    %rax,%rsp
mov    %rax,-0x40(%rbp)
movslq -0x4(%rbp),%rax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rax
sub    %rcx,%rax
mov    %rax,%rsp
mov    %rax,-0x48(%rbp)
movslq -0x4(%rbp),%rax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rax
sub    %rcx,%rax
mov    %rax,%rsp
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  0xe07(%rip),%xmm0
ucomiss -0x8c(%rbp),%xmm0
jbe    1216 <bark_noise_hybridmp+0x116>
movss  0xdf2(%rip),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xdd6(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x84(%rbp),%xmm0
ff
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x68(%rbp)
movss  0xd28(%rip),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    146d <bark_noise_hybridmp+0x36d>
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  0xcf2(%rip),%xmm0
ucomiss -0x8c(%rbp),%xmm0
jbe    132b <bark_noise_hybridmp+0x22b>
movss  0xcdd(%rip),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movss  0xba8(%rip),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    12e0 <bark_noise_hybridmp+0x1e0>
movl   $0x0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
sar    $0x10,%rax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x6c(%rbp)
jl     14a1 <bark_noise_hybridmp+0x3a1>
jmp    1665 <bark_noise_hybridmp+0x565>
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
and    $0xffff,%rax
mov    %eax,-0x70(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    1628 <bark_noise_hybridmp+0x528>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movss  0x9b0(%rip),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    147f <bark_noise_hybridmp+0x37f>
jmp    166a <bark_noise_hybridmp+0x56a>
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
sar    $0x10,%rax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
and    $0xffff,%rax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     16a3 <bark_noise_hybridmp+0x5a3>
jmp    183e <bark_noise_hybridmp+0x73e>
mov    -0x30(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    1801 <bark_noise_hybridmp+0x701>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movss  0x7d7(%rip),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    166a <bark_noise_hybridmp+0x56a>
jmp    1843 <bark_noise_hybridmp+0x743>
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18c5 <bark_noise_hybridmp+0x7c5>
movss  -0x78(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    1888 <bark_noise_hybridmp+0x788>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movss  0x750(%rip),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    1843 <bark_noise_hybridmp+0x743>
cmpl   $0x0,-0x28(%rbp)
jg     18d4 <bark_noise_hybridmp+0x7d4>
jmp    1d60 <bark_noise_hybridmp+0xc60>
movl   $0x0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x68(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x6c(%rbp)
jl     191f <bark_noise_hybridmp+0x81f>
jmp    1ade <bark_noise_hybridmp+0x9de>
mov    -0x30(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
xor    %ecx,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm1
subss  -0x24(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1ab3 <bark_noise_hybridmp+0x9b3>
movss  -0x74(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1ab8 <bark_noise_hybridmp+0x9b8>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movss  0x537(%rip),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    18e6 <bark_noise_hybridmp+0x7e6>
jmp    1ae3 <bark_noise_hybridmp+0x9e3>
mov    -0x68(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     1b1e <bark_noise_hybridmp+0xa1e>
jmp    1cc9 <bark_noise_hybridmp+0xbc9>
mov    -0x30(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm1
subss  -0x24(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1c9e <bark_noise_hybridmp+0xb9e>
movss  -0x74(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1ca3 <bark_noise_hybridmp+0xba3>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movss  0x34c(%rip),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    1ae3 <bark_noise_hybridmp+0x9e3>
jmp    1cce <bark_noise_hybridmp+0xbce>
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d60 <bark_noise_hybridmp+0xc60>
movss  -0x78(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm1
subss  -0x24(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1d35 <bark_noise_hybridmp+0xc35>
movss  -0x74(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1d3a <bark_noise_hybridmp+0xc3a>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movss  0x2b5(%rip),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
jmp    1cce <bark_noise_hybridmp+0xbce>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bark_noise_hybridmp>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
movslq %edi,%rbx
mov    %rsp,%r10
lea    0xf(,%rbx,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r10
mov    %r10,%rsp
mov    %rsp,%r11
sub    %rax,%r11
mov    %r11,%rsp
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
movss  (%rdx),%xmm2
addss  %xmm0,%xmm2
movss  0xea2(%rip),%xmm8
movaps %xmm8,%xmm4
maxss  %xmm2,%xmm4
movaps %xmm4,%xmm2
mulss  %xmm4,%xmm2
mulss  0xe8f(%rip),%xmm2
xorps  %xmm9,%xmm9
movaps %xmm2,%xmm10
addss  %xmm9,%xmm10
mulss  %xmm4,%xmm2
addss  %xmm9,%xmm2
movss  %xmm10,(%r10)
movss  %xmm10,(%r11)
movl   $0x0,(%r14)
movss  %xmm2,(%r12)
movl   $0x0,0x0(%r13)
mov    %rbx,-0x40(%rbp)
cmp    $0x2,%ebx
jl     1246 <bark_noise_hybridmp+0x146>
mov    %edi,%eax
lea    -0x4(,%rax,4),%rax
ff
xorps  %xmm4,%xmm4
xor    %ebx,%ebx
movaps %xmm8,%xmm6
movaps %xmm10,%xmm7
xchg   %ax,%ax
movss  0x4(%rdx,%rbx,1),%xmm1
addss  %xmm0,%xmm1
movaps %xmm8,%xmm5
maxss  %xmm1,%xmm5
movaps %xmm5,%xmm1
mulss  %xmm5,%xmm1
addss  %xmm1,%xmm7
movaps %xmm1,%xmm3
mulss  %xmm6,%xmm3
addss  %xmm3,%xmm10
mulss  %xmm5,%xmm1
addss  %xmm1,%xmm2
shufps $0x0,%xmm3,%xmm3
unpcklps %xmm6,%xmm5
mulps  %xmm3,%xmm5
addps  %xmm5,%xmm4
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
movss  %xmm7,0x4(%r10,%rbx,1)
movss  %xmm10,0x4(%r11,%rbx,1)
movss  %xmm1,0x4(%r14,%rbx,1)
movss  %xmm2,0x4(%r12,%rbx,1)
movss  %xmm4,0x4(%r13,%rbx,1)
addss  %xmm8,%xmm6
add    $0x4,%rbx
cmp    %rbx,%rax
jne    11d0 <bark_noise_hybridmp+0xd0>
mov    (%rsi),%rbx
bt     $0x2f,%rbx
jb     1257 <bark_noise_hybridmp+0x157>
xor    %edx,%edx
jmp    132e <bark_noise_hybridmp+0x22e>
movabs $0x800000000000,%r15
xorps  %xmm9,%xmm9
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzwl %bx,%eax
and    $0xffffffffffff0000,%rbx
shl    $0x10,%rbx
shl    $0x2,%rax
movss  (%r10,%rax,1),%xmm6
neg    %rbx
sar    $0x1e,%rbx
addss  (%r10,%rbx,1),%xmm6
movss  (%r11,%rax,1),%xmm1
subss  (%r11,%rbx,1),%xmm1
movss  (%r14,%rax,1),%xmm2
addss  (%r14,%rbx,1),%xmm2
movss  (%r12,%rax,1),%xmm5
addss  (%r12,%rbx,1),%xmm5
movss  0x0(%r13,%rax,1),%xmm3
subss  0x0(%r13,%rbx,1),%xmm3
movaps %xmm3,%xmm7
mulss  %xmm1,%xmm7
movaps %xmm5,%xmm4
mulss  %xmm2,%xmm4
subss  %xmm7,%xmm4
mulss  %xmm1,%xmm5
mulss  %xmm6,%xmm3
subss  %xmm5,%xmm3
mulss  %xmm1,%xmm1
mulss  %xmm6,%xmm2
subss  %xmm1,%xmm2
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
divss  %xmm2,%xmm1
xorps  %xmm5,%xmm5
maxss  %xmm1,%xmm5
subss  %xmm0,%xmm5
movss  %xmm5,(%rcx,%rdx,4)
addss  %xmm8,%xmm9
mov    0x8(%rsi,%rdx,8),%rbx
add    $0x1,%rdx
test   %r15,%rbx
jne    1270 <bark_noise_hybridmp+0x170>
mov    %edx,%eax
mov    (%rsi,%rax,8),%rbx
movzwl %bx,%eax
cmp    %edi,%eax
jge    13ea <bark_noise_hybridmp+0x2ea>
mov    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    %eax,%eax
movss  (%r10,%rax,4),%xmm6
shr    $0x10,%rbx
movslq %ebx,%rbx
subss  (%r10,%rbx,4),%xmm6
movss  (%r11,%rax,4),%xmm1
subss  (%r11,%rbx,4),%xmm1
movss  (%r14,%rax,4),%xmm2
subss  (%r14,%rbx,4),%xmm2
movss  (%r12,%rax,4),%xmm5
subss  (%r12,%rbx,4),%xmm5
movss  0x0(%r13,%rax,4),%xmm3
subss  0x0(%r13,%rbx,4),%xmm3
movaps %xmm3,%xmm7
mulss  %xmm1,%xmm7
movaps %xmm5,%xmm4
mulss  %xmm2,%xmm4
subss  %xmm7,%xmm4
mulss  %xmm1,%xmm5
mulss  %xmm6,%xmm3
subss  %xmm5,%xmm3
mulss  %xmm1,%xmm1
mulss  %xmm6,%xmm2
subss  %xmm1,%xmm2
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
divss  %xmm2,%xmm1
xorps  %xmm5,%xmm5
maxss  %xmm1,%xmm5
subss  %xmm0,%xmm5
movss  %xmm5,(%rcx,%rdx,4)
addss  %xmm8,%xmm9
mov    0x8(%rsi,%rdx,8),%rbx
add    $0x1,%rdx
movzwl %bx,%eax
cmp    %edi,%eax
jl     1340 <bark_noise_hybridmp+0x240>
cmp    %edi,%edx
jge    1483 <bark_noise_hybridmp+0x383>
mov    %edx,%esi
mov    %edi,%eax
sub    %edx,%eax
not    %edx
test   $0x1,%al
je     142b <bark_noise_hybridmp+0x32b>
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
divss  %xmm2,%xmm1
xorps  %xmm5,%xmm5
maxss  %xmm1,%xmm5
subss  %xmm0,%xmm5
movss  %xmm5,(%rcx,%rsi,4)
add    $0x1,%rsi
addss  0xbd5(%rip),%xmm9
add    %edi,%edx
je     1483 <bark_noise_hybridmp+0x383>
nop
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
divss  %xmm2,%xmm1
xorps  %xmm5,%xmm5
maxss  %xmm1,%xmm5
subss  %xmm0,%xmm5
movss  %xmm5,(%rcx,%rsi,4)
addss  %xmm8,%xmm9
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
divss  %xmm2,%xmm1
xorps  %xmm5,%xmm5
maxss  %xmm1,%xmm5
subss  %xmm0,%xmm5
movss  %xmm5,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
addss  %xmm8,%xmm9
cmp    %edi,%esi
jl     1430 <bark_noise_hybridmp+0x330>
test   %r8d,%r8d
jle    1703 <bark_noise_hybridmp+0x603>
mov    %r8d,%ebx
shr    %ebx
mov    %ebx,%eax
sub    %r8d,%eax
js     14a3 <bark_noise_hybridmp+0x3a3>
xor    %edx,%edx
xorps  %xmm10,%xmm10
jmp    1592 <bark_noise_hybridmp+0x492>
mov    %edi,-0x2c(%rbp)
mov    %ebx,%edi
mov    %r8d,%edx
sub    %ebx,%edx
mov    %r8d,%esi
mov    %ebx,%r9d
sub    %r8d,%r9d
add    $0x1,%r9d
add    $0x1,%rdi
xorps  %xmm10,%xmm10
xor    %r15d,%r15d
mov    %rbx,-0x38(%rbp)
jmp    14ee <bark_noise_hybridmp+0x3ee>
nopl   0x0(%rax,%rax,1)
lea    (%r9,%r15,1),%eax
mov    %r15d,%ebx
lea    0x1(%r15),%rsi
addss  %xmm8,%xmm10
add    %edi,%ebx
mov    %rsi,%r15
cmp    %rsi,%rdx
je     158b <bark_noise_hybridmp+0x48b>
movslq %ebx,%rbx
movss  (%r10,%rbx,4),%xmm9
neg    %eax
addss  (%r10,%rax,4),%xmm9
movss  (%r11,%rbx,4),%xmm1
subss  (%r11,%rax,4),%xmm1
movss  (%r14,%rbx,4),%xmm2
addss  (%r14,%rax,4),%xmm2
movss  (%r12,%rbx,4),%xmm7
addss  (%r12,%rax,4),%xmm7
movss  0x0(%r13,%rbx,4),%xmm3
subss  0x0(%r13,%rax,4),%xmm3
movaps %xmm3,%xmm6
mulss  %xmm1,%xmm6
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
subss  %xmm6,%xmm4
mulss  %xmm1,%xmm7
mulss  %xmm9,%xmm3
subss  %xmm7,%xmm3
mulss  %xmm1,%xmm1
mulss  %xmm9,%xmm2
subss  %xmm1,%xmm2
movaps %xmm10,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm4,%xmm6
divss  %xmm2,%xmm6
subss  %xmm0,%xmm6
movss  (%rcx,%r15,4),%xmm1
ucomiss %xmm6,%xmm1
jbe    14d0 <bark_noise_hybridmp+0x3d0>
movss  %xmm6,(%rcx,%r15,4)
jmp    14d0 <bark_noise_hybridmp+0x3d0>
mov    -0x2c(%rbp),%edi
mov    -0x38(%rbp),%rbx
lea    (%rdx,%rbx,1),%esi
cmp    %edi,%esi
jge    16bb <bark_noise_hybridmp+0x5bb>
mov    %edi,-0x2c(%rbp)
movslq %esi,%rsi
movslq %r8d,%rdi
movslq %edx,%rax
mov    %ebx,%ebx
add    %rax,%rbx
lea    (%r10,%rsi,4),%rax
mov    %rax,-0x38(%rbp)
lea    (%r11,%rsi,4),%rax
mov    %rax,-0x48(%rbp)
lea    (%r14,%rsi,4),%r8
lea    (%r12,%rsi,4),%r15
lea    0x0(,%rsi,4),%r9
add    %r13,%r9
sub    %rdi,%rsi
lea    (%r10,%rsi,4),%r10
lea    (%r11,%rsi,4),%r11
lea    (%r14,%rsi,4),%r14
lea    (%r12,%rsi,4),%r12
lea    0x0(%r13,%rsi,4),%r13
mov    %rbx,%rdi
xor    %eax,%eax
mov    -0x40(%rbp),%rbx
jmp    161a <bark_noise_hybridmp+0x51a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addss  %xmm8,%xmm10
lea    (%rdi,%rax,1),%rsi
add    $0x1,%rsi
add    $0x1,%rax
cmp    %rbx,%rsi
jge    16b6 <bark_noise_hybridmp+0x5b6>
mov    -0x38(%rbp),%rsi
movss  (%rsi,%rax,4),%xmm1
subss  (%r10,%rax,4),%xmm1
mov    -0x48(%rbp),%rsi
movss  (%rsi,%rax,4),%xmm6
subss  (%r11,%rax,4),%xmm6
movss  (%r8,%rax,4),%xmm2
subss  (%r14,%rax,4),%xmm2
movss  (%r15,%rax,4),%xmm7
subss  (%r12,%rax,4),%xmm7
lea    (%rdx,%rax,1),%esi
movss  (%r9,%rax,4),%xmm3
subss  0x0(%r13,%rax,4),%xmm3
movaps %xmm3,%xmm5
mulss  %xmm6,%xmm5
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
subss  %xmm5,%xmm4
mulss  %xmm6,%xmm7
mulss  %xmm1,%xmm3
subss  %xmm7,%xmm3
mulss  %xmm6,%xmm6
mulss  %xmm1,%xmm2
subss  %xmm6,%xmm2
movaps %xmm10,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm4,%xmm6
divss  %xmm2,%xmm6
subss  %xmm0,%xmm6
movss  (%rcx,%rsi,4),%xmm1
ucomiss %xmm6,%xmm1
jbe    1600 <bark_noise_hybridmp+0x500>
movss  %xmm6,(%rcx,%rsi,4)
jmp    1600 <bark_noise_hybridmp+0x500>
add    %eax,%edx
mov    -0x2c(%rbp),%edi
cmp    %edi,%edx
jge    1703 <bark_noise_hybridmp+0x603>
mov    %edx,%eax
lea    (%rcx,%rax,4),%rax
jmp    16e0 <bark_noise_hybridmp+0x5e0>
nopw   0x0(%rax,%rax,1)
addss  %xmm8,%xmm10
add    $0x4,%rax
add    $0x1,%edx
cmp    %edi,%edx
jge    1703 <bark_noise_hybridmp+0x603>
movaps %xmm10,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm4,%xmm6
divss  %xmm2,%xmm6
subss  %xmm0,%xmm6
movss  (%rax),%xmm1
ucomiss %xmm6,%xmm1
jbe    16d0 <bark_noise_hybridmp+0x5d0>
movss  %xmm6,(%rax)
jmp    16d0 <bark_noise_hybridmp+0x5d0>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @bark_noise_hybridmp(i32 %0, i64* %1, float* %2, float* %3, float %4, i32 %5) {
%7 = alloca i32
%8 = alloca i64*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float
%12 = alloca i32
%13 = alloca float*
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
store i32 %0, i32* %7
store i64* %1, i64** %8
store float* %2, float** %9
store float* %3, float** %10
store float %4, float* %11
store i32 %5, i32* %12
%33 = load i32, i32* %7
%34 = sext i32 %33 to i64
%35 = mul i64 %34, 4
%36 = alloca i8, i64 %35
%37 = bitcast i8* %36 to float*
store float* %37, float** %13
%38 = load i32, i32* %7
%39 = sext i32 %38 to i64
%40 = mul i64 %39, 4
%41 = alloca i8, i64 %40
%42 = bitcast i8* %41 to float*
store float* %42, float** %14
%43 = load i32, i32* %7
%44 = sext i32 %43 to i64
%45 = mul i64 %44, 4
%46 = alloca i8, i64 %45
%47 = bitcast i8* %46 to float*
store float* %47, float** %15
%48 = load i32, i32* %7
%49 = sext i32 %48 to i64
%50 = mul i64 %49, 4
%51 = alloca i8, i64 %50
%52 = bitcast i8* %51 to float*
store float* %52, float** %16
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = mul i64 %54, 4
%56 = alloca i8, i64 %55
%57 = bitcast i8* %56 to float*
store float* %57, float** %17
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %18
%58 = load float*, float** %9
%59 = getelementptr inbounds float, float* %58, i64 0
%60 = load float, float* %59
%61 = load float, float* %11
%62 = fadd float %60, %61
store float %62, float* %32
%63 = load float, float* %32
%64 = fcmp olt float %63, 1.000000e+00
br i1 %64, label %65, label %66
65: ; preds = %6
store float 1.000000e+00, float* %32
br label %66
66: ; preds = %65, %6
%67 = load float, float* %32
%68 = load float, float* %32
%69 = fmul float %67, %68
%70 = fpext float %69 to double
%71 = fmul double %70, 5.000000e-01
%72 = fptrunc double %71 to float
store float %72, float* %30
%73 = load float, float* %30
%74 = load float, float* %18
%75 = fadd float %74, %73
store float %75, float* %18
%76 = load float, float* %30
%77 = load float, float* %19
%78 = fadd float %77, %76
store float %78, float* %19
%79 = load float, float* %30
%80 = load float, float* %32
%81 = load float, float* %21
%82 = call float @llvm.fmuladd.f32(float %79, float %80, float %81)
store float %82, float* %21
%83 = load float, float* %18
%84 = load float*, float** %13
%85 = getelementptr inbounds float, float* %84, i64 0
store float %83, float* %85
%86 = load float, float* %19
%87 = load float*, float** %14
%88 = getelementptr inbounds float, float* %87, i64 0
store float %86, float* %88
%89 = load float, float* %20
%90 = load float*, float** %15
%91 = getelementptr inbounds float, float* %90, i64 0
store float %89, float* %91
%92 = load float, float* %21
%93 = load float*, float** %16
%94 = getelementptr inbounds float, float* %93, i64 0
store float %92, float* %94
%95 = load float, float* %22
%96 = load float*, float** %17
%97 = getelementptr inbounds float, float* %96, i64 0
store float %95, float* %97
store i32 1, i32* %23
store float 1.000000e+00, float* %31
br label %98
98: ; preds = %165, %66
%99 = load i32, i32* %23
%100 = load i32, i32* %7
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %170
102: ; preds = %98
%103 = load float*, float** %9
%104 = load i32, i32* %23
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %103, i64 %105
%107 = load float, float* %106
%108 = load float, float* %11
%109 = fadd float %107, %108
store float %109, float* %32
%110 = load float, float* %32
%111 = fcmp olt float %110, 1.000000e+00
br i1 %111, label %112, label %113
112: ; preds = %102
store float 1.000000e+00, float* %32
br label %113
113: ; preds = %112, %102
%114 = load float, float* %32
%115 = load float, float* %32
%116 = fmul float %114, %115
store float %116, float* %30
%117 = load float, float* %30
%118 = load float, float* %18
%119 = fadd float %118, %117
store float %119, float* %18
%120 = load float, float* %30
%121 = load float, float* %31
%122 = load float, float* %19
%123 = call float @llvm.fmuladd.f32(float %120, float %121, float %122)
store float %123, float* %19
%124 = load float, float* %30
%125 = load float, float* %31
%126 = fmul float %124, %125
%127 = load float, float* %31
%128 = load float, float* %20
%129 = call float @llvm.fmuladd.f32(float %126, float %127, float %128)
store float %129, float* %20
%130 = load float, float* %30
%131 = load float, float* %32
%132 = load float, float* %21
%133 = call float @llvm.fmuladd.f32(float %130, float %131, float %132)
store float %133, float* %21
%134 = load float, float* %30
%135 = load float, float* %31
%136 = fmul float %134, %135
%137 = load float, float* %32
%138 = load float, float* %22
%139 = call float @llvm.fmuladd.f32(float %136, float %137, float %138)
store float %139, float* %22
%140 = load float, float* %18
%141 = load float*, float** %13
%142 = load i32, i32* %23
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %141, i64 %143
store float %140, float* %144
%145 = load float, float* %19
%146 = load float*, float** %14
%147 = load i32, i32* %23
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %146, i64 %148
store float %145, float* %149
%150 = load float, float* %20
%151 = load float*, float** %15
%152 = load i32, i32* %23
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %151, i64 %153
store float %150, float* %154
%155 = load float, float* %21
%156 = load float*, float** %16
%157 = load i32, i32* %23
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float, float* %156, i64 %158
store float %155, float* %159
%160 = load float, float* %22
%161 = load float*, float** %17
%162 = load i32, i32* %23
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %161, i64 %163
store float %160, float* %164
br label %165
165: ; preds = %113
%166 = load i32, i32* %23
%167 = add nsw i32 %166, 1
store i32 %167, i32* %23
%168 = load float, float* %31
%169 = fadd float %168, 1.000000e+00
store float %169, float* %31
br label %98
170: ; preds = %98
store i32 0, i32* %23
store float 0.000000e+00, float* %31
br label %171
171: ; preds = %288, %170
%172 = load i64*, i64** %8
%173 = load i32, i32* %23
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i64, i64* %172, i64 %174
%176 = load i64, i64* %175
%177 = ashr i64 %176, 16
%178 = trunc i64 %177 to i32
store i32 %178, i32* %24
%179 = load i32, i32* %24
%180 = icmp sge i32 %179, 0
br i1 %180, label %181, label %182
181: ; preds = %171
br label %293
182: ; preds = %171
%183 = load i64*, i64** %8
%184 = load i32, i32* %23
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i64, i64* %183, i64 %185
%187 = load i64, i64* %186
%188 = and i64 %187, 65535
%189 = trunc i64 %188 to i32
store i32 %189, i32* %25
%190 = load float*, float** %13
%191 = load i32, i32* %25
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds float, float* %190, i64 %192
%194 = load float, float* %193
%195 = load float*, float** %13
%196 = load i32, i32* %24
%197 = sub nsw i32 0, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %195, i64 %198
%200 = load float, float* %199
%201 = fadd float %194, %200
store float %201, float* %18
%202 = load float*, float** %14
%203 = load i32, i32* %25
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds float, float* %202, i64 %204
%206 = load float, float* %205
%207 = load float*, float** %14
%208 = load i32, i32* %24
%209 = sub nsw i32 0, %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %207, i64 %210
%212 = load float, float* %211
%213 = fsub float %206, %212
store float %213, float* %19
%214 = load float*, float** %15
%215 = load i32, i32* %25
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %214, i64 %216
%218 = load float, float* %217
%219 = load float*, float** %15
%220 = load i32, i32* %24
%221 = sub nsw i32 0, %220
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float, float* %219, i64 %222
%224 = load float, float* %223
%225 = fadd float %218, %224
store float %225, float* %20
%226 = load float*, float** %16
%227 = load i32, i32* %25
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %226, i64 %228
%230 = load float, float* %229
%231 = load float*, float** %16
%232 = load i32, i32* %24
%233 = sub nsw i32 0, %232
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds float, float* %231, i64 %234
%236 = load float, float* %235
%237 = fadd float %230, %236
store float %237, float* %21
%238 = load float*, float** %17
%239 = load i32, i32* %25
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds float, float* %238, i64 %240
%242 = load float, float* %241
%243 = load float*, float** %17
%244 = load i32, i32* %24
%245 = sub nsw i32 0, %244
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float, float* %243, i64 %246
%248 = load float, float* %247
%249 = fsub float %242, %248
store float %249, float* %22
%250 = load float, float* %21
%251 = load float, float* %20
%252 = load float, float* %19
%253 = load float, float* %22
%254 = fmul float %252, %253
%255 = fneg float %254
%256 = call float @llvm.fmuladd.f32(float %250, float %251, float %255)
store float %256, float* %27
%257 = load float, float* %18
%258 = load float, float* %22
%259 = load float, float* %19
%260 = load float, float* %21
%261 = fmul float %259, %260
%262 = fneg float %261
%263 = call float @llvm.fmuladd.f32(float %257, float %258, float %262)
store float %263, float* %28
%264 = load float, float* %18
%265 = load float, float* %20
%266 = load float, float* %19
%267 = load float, float* %19
%268 = fmul float %266, %267
%269 = fneg float %268
%270 = call float @llvm.fmuladd.f32(float %264, float %265, float %269)
store float %270, float* %29
%271 = load float, float* %27
%272 = load float, float* %31
%273 = load float, float* %28
%274 = call float @llvm.fmuladd.f32(float %272, float %273, float %271)
%275 = load float, float* %29
%276 = fdiv float %274, %275
store float %276, float* %26
%277 = load float, float* %26
%278 = fcmp olt float %277, 0.000000e+00
br i1 %278, label %279, label %280
279: ; preds = %182
store float 0.000000e+00, float* %26
br label %280
280: ; preds = %279, %182
%281 = load float, float* %26
%282 = load float, float* %11
%283 = fsub float %281, %282
%284 = load float*, float** %10
%285 = load i32, i32* %23
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds float, float* %284, i64 %286
store float %283, float* %287
br label %288
288: ; preds = %280
%289 = load i32, i32* %23
%290 = add nsw i32 %289, 1
store i32 %290, i32* %23
%291 = load float, float* %31
%292 = fadd float %291, 1.000000e+00
store float %292, float* %31
br label %171
293: ; preds = %181
br label %294
294: ; preds = %407, %293
%295 = load i64*, i64** %8
%296 = load i32, i32* %23
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i64, i64* %295, i64 %297
%299 = load i64, i64* %298
%300 = ashr i64 %299, 16
%301 = trunc i64 %300 to i32
store i32 %301, i32* %24
%302 = load i64*, i64** %8
%303 = load i32, i32* %23
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i64, i64* %302, i64 %304
%306 = load i64, i64* %305
%307 = and i64 %306, 65535
%308 = trunc i64 %307 to i32
store i32 %308, i32* %25
%309 = load i32, i32* %25
%310 = load i32, i32* %7
%311 = icmp sge i32 %309, %310
br i1 %311, label %312, label %313
312: ; preds = %294
br label %412
313: ; preds = %294
%314 = load float*, float** %13
%315 = load i32, i32* %25
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %314, i64 %316
%318 = load float, float* %317
%319 = load float*, float** %13
%320 = load i32, i32* %24
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds float, float* %319, i64 %321
%323 = load float, float* %322
%324 = fsub float %318, %323
store float %324, float* %18
%325 = load float*, float** %14
%326 = load i32, i32* %25
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %325, i64 %327
%329 = load float, float* %328
%330 = load float*, float** %14
%331 = load i32, i32* %24
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %330, i64 %332
%334 = load float, float* %333
%335 = fsub float %329, %334
store float %335, float* %19
%336 = load float*, float** %15
%337 = load i32, i32* %25
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds float, float* %336, i64 %338
%340 = load float, float* %339
%341 = load float*, float** %15
%342 = load i32, i32* %24
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds float, float* %341, i64 %343
%345 = load float, float* %344
%346 = fsub float %340, %345
store float %346, float* %20
%347 = load float*, float** %16
%348 = load i32, i32* %25
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds float, float* %347, i64 %349
%351 = load float, float* %350
%352 = load float*, float** %16
%353 = load i32, i32* %24
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds float, float* %352, i64 %354
%356 = load float, float* %355
%357 = fsub float %351, %356
store float %357, float* %21
%358 = load float*, float** %17
%359 = load i32, i32* %25
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds float, float* %358, i64 %360
%362 = load float, float* %361
%363 = load float*, float** %17
%364 = load i32, i32* %24
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds float, float* %363, i64 %365
%367 = load float, float* %366
%368 = fsub float %362, %367
store float %368, float* %22
%369 = load float, float* %21
%370 = load float, float* %20
%371 = load float, float* %19
%372 = load float, float* %22
%373 = fmul float %371, %372
%374 = fneg float %373
%375 = call float @llvm.fmuladd.f32(float %369, float %370, float %374)
store float %375, float* %27
%376 = load float, float* %18
%377 = load float, float* %22
%378 = load float, float* %19
%379 = load float, float* %21
%380 = fmul float %378, %379
%381 = fneg float %380
%382 = call float @llvm.fmuladd.f32(float %376, float %377, float %381)
store float %382, float* %28
%383 = load float, float* %18
%384 = load float, float* %20
%385 = load float, float* %19
%386 = load float, float* %19
%387 = fmul float %385, %386
%388 = fneg float %387
%389 = call float @llvm.fmuladd.f32(float %383, float %384, float %388)
store float %389, float* %29
%390 = load float, float* %27
%391 = load float, float* %31
%392 = load float, float* %28
%393 = call float @llvm.fmuladd.f32(float %391, float %392, float %390)
%394 = load float, float* %29
%395 = fdiv float %393, %394
store float %395, float* %26
%396 = load float, float* %26
%397 = fcmp olt float %396, 0.000000e+00
br i1 %397, label %398, label %399
398: ; preds = %313
store float 0.000000e+00, float* %26
br label %399
399: ; preds = %398, %313
%400 = load float, float* %26
%401 = load float, float* %11
%402 = fsub float %400, %401
%403 = load float*, float** %10
%404 = load i32, i32* %23
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %403, i64 %405
store float %402, float* %406
br label %407
407: ; preds = %399
%408 = load i32, i32* %23
%409 = add nsw i32 %408, 1
store i32 %409, i32* %23
%410 = load float, float* %31
%411 = fadd float %410, 1.000000e+00
store float %411, float* %31
br label %294
412: ; preds = %312
br label %413
413: ; preds = %435, %412
%414 = load i32, i32* %23
%415 = load i32, i32* %7
%416 = icmp slt i32 %414, %415
br i1 %416, label %417, label %440
417: ; preds = %413
%418 = load float, float* %27
%419 = load float, float* %31
%420 = load float, float* %28
%421 = call float @llvm.fmuladd.f32(float %419, float %420, float %418)
%422 = load float, float* %29
%423 = fdiv float %421, %422
store float %423, float* %26
%424 = load float, float* %26
%425 = fcmp olt float %424, 0.000000e+00
br i1 %425, label %426, label %427
426: ; preds = %417
store float 0.000000e+00, float* %26
br label %427
427: ; preds = %426, %417
%428 = load float, float* %26
%429 = load float, float* %11
%430 = fsub float %428, %429
%431 = load float*, float** %10
%432 = load i32, i32* %23
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds float, float* %431, i64 %433
store float %430, float* %434
br label %435
435: ; preds = %427
%436 = load i32, i32* %23
%437 = add nsw i32 %436, 1
store i32 %437, i32* %23
%438 = load float, float* %31
%439 = fadd float %438, 1.000000e+00
store float %439, float* %31
br label %413
440: ; preds = %413
%441 = load i32, i32* %12
%442 = icmp sle i32 %441, 0
br i1 %442, label %443, label %444
443: ; preds = %440
br label %721
444: ; preds = %440
store i32 0, i32* %23
store float 0.000000e+00, float* %31
br label %445
445: ; preds = %562, %444
%446 = load i32, i32* %23
%447 = load i32, i32* %12
%448 = sdiv i32 %447, 2
%449 = add nsw i32 %446, %448
store i32 %449, i32* %25
%450 = load i32, i32* %25
%451 = load i32, i32* %12
%452 = sub nsw i32 %450, %451
store i32 %452, i32* %24
%453 = load i32, i32* %24
%454 = icmp sge i32 %453, 0
br i1 %454, label %455, label %456
455: ; preds = %445
br label %567
456: ; preds = %445
%457 = load float*, float** %13
%458 = load i32, i32* %25
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float, float* %457, i64 %459
%461 = load float, float* %460
%462 = load float*, float** %13
%463 = load i32, i32* %24
%464 = sub nsw i32 0, %463
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds float, float* %462, i64 %465
%467 = load float, float* %466
%468 = fadd float %461, %467
store float %468, float* %18
%469 = load float*, float** %14
%470 = load i32, i32* %25
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float, float* %469, i64 %471
%473 = load float, float* %472
%474 = load float*, float** %14
%475 = load i32, i32* %24
%476 = sub nsw i32 0, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds float, float* %474, i64 %477
%479 = load float, float* %478
%480 = fsub float %473, %479
store float %480, float* %19
%481 = load float*, float** %15
%482 = load i32, i32* %25
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds float, float* %481, i64 %483
%485 = load float, float* %484
%486 = load float*, float** %15
%487 = load i32, i32* %24
%488 = sub nsw i32 0, %487
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds float, float* %486, i64 %489
%491 = load float, float* %490
%492 = fadd float %485, %491
store float %492, float* %20
%493 = load float*, float** %16
%494 = load i32, i32* %25
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds float, float* %493, i64 %495
%497 = load float, float* %496
%498 = load float*, float** %16
%499 = load i32, i32* %24
%500 = sub nsw i32 0, %499
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds float, float* %498, i64 %501
%503 = load float, float* %502
%504 = fadd float %497, %503
store float %504, float* %21
%505 = load float*, float** %17
%506 = load i32, i32* %25
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds float, float* %505, i64 %507
%509 = load float, float* %508
%510 = load float*, float** %17
%511 = load i32, i32* %24
%512 = sub nsw i32 0, %511
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds float, float* %510, i64 %513
%515 = load float, float* %514
%516 = fsub float %509, %515
store float %516, float* %22
%517 = load float, float* %21
%518 = load float, float* %20
%519 = load float, float* %19
%520 = load float, float* %22
%521 = fmul float %519, %520
%522 = fneg float %521
%523 = call float @llvm.fmuladd.f32(float %517, float %518, float %522)
store float %523, float* %27
%524 = load float, float* %18
%525 = load float, float* %22
%526 = load float, float* %19
%527 = load float, float* %21
%528 = fmul float %526, %527
%529 = fneg float %528
%530 = call float @llvm.fmuladd.f32(float %524, float %525, float %529)
store float %530, float* %28
%531 = load float, float* %18
%532 = load float, float* %20
%533 = load float, float* %19
%534 = load float, float* %19
%535 = fmul float %533, %534
%536 = fneg float %535
%537 = call float @llvm.fmuladd.f32(float %531, float %532, float %536)
store float %537, float* %29
%538 = load float, float* %27
%539 = load float, float* %31
%540 = load float, float* %28
%541 = call float @llvm.fmuladd.f32(float %539, float %540, float %538)
%542 = load float, float* %29
%543 = fdiv float %541, %542
store float %543, float* %26
%544 = load float, float* %26
%545 = load float, float* %11
%546 = fsub float %544, %545
%547 = load float*, float** %10
%548 = load i32, i32* %23
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds float, float* %547, i64 %549
%551 = load float, float* %550
%552 = fcmp olt float %546, %551
br i1 %552, label %553, label %561
553: ; preds = %456
%554 = load float, float* %26
%555 = load float, float* %11
%556 = fsub float %554, %555
%557 = load float*, float** %10
%558 = load i32, i32* %23
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds float, float* %557, i64 %559
store float %556, float* %560
br label %561
561: ; preds = %553, %456
br label %562
562: ; preds = %561
%563 = load i32, i32* %23
%564 = add nsw i32 %563, 1
store i32 %564, i32* %23
%565 = load float, float* %31
%566 = fadd float %565, 1.000000e+00
store float %566, float* %31
br label %445
567: ; preds = %455
br label %568
568: ; preds = %681, %567
%569 = load i32, i32* %23
%570 = load i32, i32* %12
%571 = sdiv i32 %570, 2
%572 = add nsw i32 %569, %571
store i32 %572, i32* %25
%573 = load i32, i32* %25
%574 = load i32, i32* %12
%575 = sub nsw i32 %573, %574
store i32 %575, i32* %24
%576 = load i32, i32* %25
%577 = load i32, i32* %7
%578 = icmp sge i32 %576, %577
br i1 %578, label %579, label %580
579: ; preds = %568
br label %686
580: ; preds = %568
%581 = load float*, float** %13
%582 = load i32, i32* %25
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds float, float* %581, i64 %583
%585 = load float, float* %584
%586 = load float*, float** %13
%587 = load i32, i32* %24
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds float, float* %586, i64 %588
%590 = load float, float* %589
%591 = fsub float %585, %590
store float %591, float* %18
%592 = load float*, float** %14
%593 = load i32, i32* %25
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds float, float* %592, i64 %594
%596 = load float, float* %595
%597 = load float*, float** %14
%598 = load i32, i32* %24
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds float, float* %597, i64 %599
%601 = load float, float* %600
%602 = fsub float %596, %601
store float %602, float* %19
%603 = load float*, float** %15
%604 = load i32, i32* %25
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds float, float* %603, i64 %605
%607 = load float, float* %606
%608 = load float*, float** %15
%609 = load i32, i32* %24
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float, float* %608, i64 %610
%612 = load float, float* %611
%613 = fsub float %607, %612
store float %613, float* %20
%614 = load float*, float** %16
%615 = load i32, i32* %25
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds float, float* %614, i64 %616
%618 = load float, float* %617
%619 = load float*, float** %16
%620 = load i32, i32* %24
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds float, float* %619, i64 %621
%623 = load float, float* %622
%624 = fsub float %618, %623
store float %624, float* %21
%625 = load float*, float** %17
%626 = load i32, i32* %25
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds float, float* %625, i64 %627
%629 = load float, float* %628
%630 = load float*, float** %17
%631 = load i32, i32* %24
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds float, float* %630, i64 %632
%634 = load float, float* %633
%635 = fsub float %629, %634
store float %635, float* %22
%636 = load float, float* %21
%637 = load float, float* %20
%638 = load float, float* %19
%639 = load float, float* %22
%640 = fmul float %638, %639
%641 = fneg float %640
%642 = call float @llvm.fmuladd.f32(float %636, float %637, float %641)
store float %642, float* %27
%643 = load float, float* %18
%644 = load float, float* %22
%645 = load float, float* %19
%646 = load float, float* %21
%647 = fmul float %645, %646
%648 = fneg float %647
%649 = call float @llvm.fmuladd.f32(float %643, float %644, float %648)
store float %649, float* %28
%650 = load float, float* %18
%651 = load float, float* %20
%652 = load float, float* %19
%653 = load float, float* %19
%654 = fmul float %652, %653
%655 = fneg float %654
%656 = call float @llvm.fmuladd.f32(float %650, float %651, float %655)
store float %656, float* %29
%657 = load float, float* %27
%658 = load float, float* %31
%659 = load float, float* %28
%660 = call float @llvm.fmuladd.f32(float %658, float %659, float %657)
%661 = load float, float* %29
%662 = fdiv float %660, %661
store float %662, float* %26
%663 = load float, float* %26
%664 = load float, float* %11
%665 = fsub float %663, %664
%666 = load float*, float** %10
%667 = load i32, i32* %23
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds float, float* %666, i64 %668
%670 = load float, float* %669
%671 = fcmp olt float %665, %670
br i1 %671, label %672, label %680
672: ; preds = %580
%673 = load float, float* %26
%674 = load float, float* %11
%675 = fsub float %673, %674
%676 = load float*, float** %10
%677 = load i32, i32* %23
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds float, float* %676, i64 %678
store float %675, float* %679
br label %680
680: ; preds = %672, %580
br label %681
681: ; preds = %680
%682 = load i32, i32* %23
%683 = add nsw i32 %682, 1
store i32 %683, i32* %23
%684 = load float, float* %31
%685 = fadd float %684, 1.000000e+00
store float %685, float* %31
br label %568
686: ; preds = %579
br label %687
687: ; preds = %716, %686
%688 = load i32, i32* %23
%689 = load i32, i32* %7
%690 = icmp slt i32 %688, %689
br i1 %690, label %691, label %721
691: ; preds = %687
%692 = load float, float* %27
%693 = load float, float* %31
%694 = load float, float* %28
%695 = call float @llvm.fmuladd.f32(float %693, float %694, float %692)
%696 = load float, float* %29
%697 = fdiv float %695, %696
store float %697, float* %26
%698 = load float, float* %26
%699 = load float, float* %11
%700 = fsub float %698, %699
%701 = load float*, float** %10
%702 = load i32, i32* %23
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds float, float* %701, i64 %703
%705 = load float, float* %704
%706 = fcmp olt float %700, %705
br i1 %706, label %707, label %715
707: ; preds = %691
%708 = load float, float* %26
%709 = load float, float* %11
%710 = fsub float %708, %709
%711 = load float*, float** %10
%712 = load i32, i32* %23
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds float, float* %711, i64 %713
store float %710, float* %714
br label %715
715: ; preds = %707, %691
br label %716
716: ; preds = %715
%717 = load i32, i32* %23
%718 = add nsw i32 %717, 1
store i32 %718, i32* %23
%719 = load float, float* %31
%720 = fadd float %719, 1.000000e+00
store float %720, float* %31
br label %687
721: ; preds = %443, %687
ret void
}

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