void dt_iop_equalizer_iwtf(float *buf, float **weight_a, const int l,
                           const int width, const int height) {
  const int step = 1 << l;
  const int st = step / 2;
  const int wd = (int)(1 + (width >> (l - 1)));
  for (int i = 0; i < width; i++) {
    float tmp[height];
    int j;
    for (j = 0; j < height - st; j += st)
      tmp[j] =
          1.0 /
          (fabsf(weight_a[l][wd * ((j) >> (l - 1)) + ((i) >> (l - 1))] -
                 weight_a[l][wd * ((j + st) >> (l - 1)) + ((i) >> (l - 1))]) +
           1.e-5);
    for (int ch = 0; ch < 3; ch++)
      ((buf)[4 * (width * ((0)) + ((i))) + ch]) -=
          ((buf)[4 * (width * ((st)) + ((i))) + ch]) * 0.5f;
    for (j = step; j < height - st; j += step)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) -=
            (tmp[j - st] * ((buf)[4 * (width * ((j - st)) + ((i))) + ch]) +
             tmp[j] * ((buf)[4 * (width * ((j + st)) + ((i))) + ch])) /
            (2.0 * (tmp[j - st] + tmp[j]));
    if (j < height)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) -=
            ((buf)[4 * (width * ((j - st)) + ((i))) + ch]) * .5f;
    for (j = st; j < height - st; j += step)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) +=
            (tmp[j - st] * ((buf)[4 * (width * ((j - st)) + ((i))) + ch]) +
             tmp[j] * ((buf)[4 * (width * ((j + st)) + ((i))) + ch])) /
            (tmp[j - st] + tmp[j]);
    if (j < height)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) +=
            ((buf)[4 * (width * ((j - st)) + ((i))) + ch]);
  }
  for (int j = 0; j < height; j++) {
    float tmp[width];
    int i;
    for (int i = 0; i < width - st; i += st)
      tmp[i] =
          1.0 /
          (fabsf(weight_a[l][wd * ((j) >> (l - 1)) + ((i) >> (l - 1))] -
                 weight_a[l][wd * ((j) >> (l - 1)) + ((i + st) >> (l - 1))]) +
           1.e-5);
    for (int ch = 0; ch < 3; ch++)
      ((buf)[4 * (width * ((j)) + ((0))) + ch]) -=
          ((buf)[4 * (width * ((j)) + ((st))) + ch]) * 0.5f;
    for (i = step; i < width - st; i += step)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) -=
            (tmp[i - st] * ((buf)[4 * (width * ((j)) + ((i - st))) + ch]) +
             tmp[i] * ((buf)[4 * (width * ((j)) + ((i + st))) + ch])) /
            (2.0 * (tmp[i - st] + tmp[i]));
    if (i < width)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) -=
            ((buf)[4 * (width * ((j)) + ((i - st))) + ch]) * 0.5f;
    for (i = st; i < width - st; i += step)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) +=
            (tmp[i - st] * ((buf)[4 * (width * ((j)) + ((i - st))) + ch]) +
             tmp[i] * ((buf)[4 * (width * ((j)) + ((i + st))) + ch])) /
            (tmp[i - st] + tmp[i]);
    if (i < width)
      for (int ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) +=
            ((buf)[4 * (width * ((j)) + ((i - st))) + ch]);
  }
}


x86 assembly (clang, -O0):
<dt_iop_equalizer_iwtf>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x14(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15f6 <dt_iop_equalizer_iwtf+0x4f6>
mov    -0x1c(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    126e <dt_iop_equalizer_iwtf+0x16e>
mov    -0x98(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %rcx,-0xa8(%rbp)
mov    -0x28(%rbp),%edx
mov    -0x44(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x2c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0xa8(%rbp),%rcx
add    %esi,%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %rcx,-0xa0(%rbp)
mov    -0x28(%rbp),%edx
mov    -0x44(%rbp),%esi
add    -0x24(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x2c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0xa0(%rbp),%rcx
add    %esi,%edx
movslq %edx,%rdx
subss  (%rcx,%rdx,4),%xmm0
movaps 0xded(%rip),%xmm1
pand   %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdd5(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0xdc1(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    118d <dt_iop_equalizer_iwtf+0x8d>
movl   $0x0,-0x48(%rbp)
cmpl   $0x3,-0x48(%rbp)
jge    12e5 <dt_iop_equalizer_iwtf+0x1e5>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x0,-0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
movss  0xd36(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1275 <dt_iop_equalizer_iwtf+0x175>
mov    -0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    13f2 <dt_iop_equalizer_iwtf+0x2f2>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x3,-0x4c(%rbp)
jge    13df <dt_iop_equalizer_iwtf+0x2df>
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x44(%rbp),%esi
sub    -0x24(%rbp),%esi
imul   %esi,%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    -0x4c(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x44(%rbp),%esi
add    -0x24(%rbp),%esi
imul   %esi,%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    -0x4c(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xc6c(%rip),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1303 <dt_iop_equalizer_iwtf+0x203>
jmp    13e4 <dt_iop_equalizer_iwtf+0x2e4>
mov    -0x20(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    12eb <dt_iop_equalizer_iwtf+0x1eb>
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1482 <dt_iop_equalizer_iwtf+0x382>
movl   $0x0,-0x50(%rbp)
cmpl   $0x3,-0x50(%rbp)
jge    147d <dt_iop_equalizer_iwtf+0x37d>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x44(%rbp),%edx
sub    -0x24(%rbp),%edx
imul   %edx,%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
movss  0xb9e(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1405 <dt_iop_equalizer_iwtf+0x305>
jmp    1482 <dt_iop_equalizer_iwtf+0x382>
mov    -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    156f <dt_iop_equalizer_iwtf+0x46f>
movl   $0x0,-0x54(%rbp)
cmpl   $0x3,-0x54(%rbp)
jge    155c <dt_iop_equalizer_iwtf+0x45c>
mov    -0x98(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x44(%rbp),%esi
sub    -0x24(%rbp),%esi
imul   %esi,%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    -0x54(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x44(%rbp),%esi
add    -0x24(%rbp),%esi
imul   %esi,%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    -0x54(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14a0 <dt_iop_equalizer_iwtf+0x3a0>
jmp    1561 <dt_iop_equalizer_iwtf+0x461>
mov    -0x20(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1488 <dt_iop_equalizer_iwtf+0x388>
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15e1 <dt_iop_equalizer_iwtf+0x4e1>
movl   $0x0,-0x58(%rbp)
cmpl   $0x3,-0x58(%rbp)
jge    15dc <dt_iop_equalizer_iwtf+0x4dc>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x44(%rbp),%edx
sub    -0x24(%rbp),%edx
imul   %edx,%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1582 <dt_iop_equalizer_iwtf+0x482>
jmp    15e1 <dt_iop_equalizer_iwtf+0x4e1>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1150 <dt_iop_equalizer_iwtf+0x50>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1adf <dt_iop_equalizer_iwtf+0x9df>
mov    -0x18(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x68(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    171b <dt_iop_equalizer_iwtf+0x61b>
mov    -0xb0(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %rcx,-0xc0(%rbp)
mov    -0x28(%rbp),%edx
mov    -0x5c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x78(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0xc0(%rbp),%rcx
add    %esi,%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %rcx,-0xb8(%rbp)
mov    -0x28(%rbp),%edx
mov    -0x5c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x78(%rbp),%esi
add    -0x24(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0xb8(%rbp),%rcx
add    %esi,%edx
movslq %edx,%rdx
subss  (%rcx,%rdx,4),%xmm0
movaps 0x940(%rip),%xmm1
pand   %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x928(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x914(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    163a <dt_iop_equalizer_iwtf+0x53a>
movl   $0x0,-0x7c(%rbp)
cmpl   $0x3,-0x7c(%rbp)
jge    1795 <dt_iop_equalizer_iwtf+0x695>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
movss  0x886(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1722 <dt_iop_equalizer_iwtf+0x622>
mov    -0x20(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    18a2 <dt_iop_equalizer_iwtf+0x7a2>
movl   $0x0,-0x80(%rbp)
cmpl   $0x3,-0x80(%rbp)
jge    188f <dt_iop_equalizer_iwtf+0x78f>
mov    -0xb0(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x5c(%rbp),%edx
mov    -0x74(%rbp),%esi
sub    -0x24(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x80(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x5c(%rbp),%edx
mov    -0x74(%rbp),%esi
add    -0x24(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x80(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x74(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x74(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0x7bc(%rip),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    17b3 <dt_iop_equalizer_iwtf+0x6b3>
jmp    1894 <dt_iop_equalizer_iwtf+0x794>
mov    -0x20(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    179b <dt_iop_equalizer_iwtf+0x69b>
mov    -0x74(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1944 <dt_iop_equalizer_iwtf+0x844>
movl   $0x0,-0x84(%rbp)
cmpl   $0x3,-0x84(%rbp)
jge    193f <dt_iop_equalizer_iwtf+0x83f>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
mov    -0x74(%rbp),%edx
sub    -0x24(%rbp),%edx
add    %edx,%ecx
shl    $0x2,%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
movss  0x6e2(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    18b8 <dt_iop_equalizer_iwtf+0x7b8>
jmp    1944 <dt_iop_equalizer_iwtf+0x844>
mov    -0x24(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    1a46 <dt_iop_equalizer_iwtf+0x946>
movl   $0x0,-0x88(%rbp)
cmpl   $0x3,-0x88(%rbp)
jge    1a33 <dt_iop_equalizer_iwtf+0x933>
mov    -0xb0(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x5c(%rbp),%edx
mov    -0x74(%rbp),%esi
sub    -0x24(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x5c(%rbp),%edx
mov    -0x74(%rbp),%esi
add    -0x24(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x74(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movslq -0x74(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1965 <dt_iop_equalizer_iwtf+0x865>
jmp    1a38 <dt_iop_equalizer_iwtf+0x938>
mov    -0x20(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    194a <dt_iop_equalizer_iwtf+0x84a>
mov    -0x74(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1aca <dt_iop_equalizer_iwtf+0x9ca>
movl   $0x0,-0x8c(%rbp)
cmpl   $0x3,-0x8c(%rbp)
jge    1ac5 <dt_iop_equalizer_iwtf+0x9c5>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
mov    -0x74(%rbp),%edx
sub    -0x24(%rbp),%edx
add    %edx,%ecx
shl    $0x2,%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1a5c <dt_iop_equalizer_iwtf+0x95c>
jmp    1aca <dt_iop_equalizer_iwtf+0x9ca>
mov    -0x68(%rbp),%rax
mov    %rax,%rsp
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    15fd <dt_iop_equalizer_iwtf+0x4fd>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dt_iop_equalizer_iwtf>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %ecx,%ebx
mov    %edx,%r9d
mov    %rsi,-0xe8(%rbp)
mov    $0x1,%edx
mov    %r9d,%ecx
shl    %cl,%edx
mov    %edx,%r13d
shr    $0x1f,%r13d
lea    -0x1(%r9),%r11d
mov    %ebx,%r12d
mov    %r11d,%ecx
sar    %cl,%r12d
add    %edx,%r13d
sar    %r13d
add    $0x1,%r12d
mov    %r8d,-0x30(%rbp)
mov    %r8d,%eax
mov    %rax,-0xd8(%rbp)
movslq %r9d,%rax
mov    %rax,-0xe0(%rbp)
movslq %r13d,%r10
mov    %ebx,%eax
mov    %rax,-0xc8(%rbp)
test   %ebx,%ebx
mov    %rbx,-0x58(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %r13,-0x48(%rbp)
mov    %r11d,-0x90(%rbp)
mov    %r12d,-0x8c(%rbp)
mov    %r10,-0xb8(%rbp)
jle    1723 <dt_iop_equalizer_iwtf+0x623>
mov    -0x30(%rbp),%ecx
sub    %r10d,%ecx
mov    %r13d,%edx
mov    -0x58(%rbp),%rax
imul   %eax,%edx
mov    %ecx,-0x70(%rbp)
movslq %ecx,%rsi
mov    -0x40(%rbp),%rbx
movslq %ebx,%r15
mov    %ebx,%ecx
sub    %r10d,%ecx
imul   %eax,%ecx
shl    $0x2,%ecx
mov    %rcx,-0xc0(%rbp)
mov    %ebx,%ecx
imul   %eax,%ecx
mov    %rcx,-0xa8(%rbp)
lea    0x0(,%rcx,4),%r9d
lea    (%rbx,%r13,1),%ecx
imul   %eax,%ecx
mov    %rcx,-0xa0(%rbp)
lea    0x0(,%r10,4),%rax
neg    %rax
mov    %rax,-0x98(%rbp)
lea    0x0(,%rdx,8),%ecx
mov    %rdx,-0x60(%rbp)
lea    0x0(,%rdx,4),%eax
mov    %rax,-0x80(%rbp)
xor    %ebx,%ebx
mov    -0xd8(%rbp),%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,-0xb0(%rbp)
movaps 0xdcf(%rip),%xmm0
movsd  0xdd7(%rip),%xmm1
movsd  0xdd7(%rip),%xmm2
movss  0xdd6(%rip),%xmm8
mov    %rsi,-0x88(%rbp)
mov    %r15,-0x78(%rbp)
mov    %rcx,-0x38(%rbp)
jmp    128a <dt_iop_equalizer_iwtf+0x18a>
nopl   0x0(%rax,%rax,1)
mov    -0x68(%rbp),%rsp
add    $0x1,%rbx
cmp    -0xc8(%rbp),%rbx
mov    -0x90(%rbp),%r11d
mov    -0x8c(%rbp),%r12d
mov    -0xb8(%rbp),%r10
je     1723 <dt_iop_equalizer_iwtf+0x623>
mov    %rsp,%rax
mov    %rsp,%r8
sub    -0xb0(%rbp),%r8
mov    %r8,%rsp
cmpl   $0x0,-0x70(%rbp)
mov    %rax,-0x68(%rbp)
jle    1335 <dt_iop_equalizer_iwtf+0x235>
mov    -0xe8(%rbp),%rax
mov    -0xe0(%rbp),%rcx
mov    %r10,%r14
mov    (%rax,%rcx,8),%r10
mov    %rbx,-0x50(%rbp)
mov    %ebx,%edx
mov    %r11d,%ecx
shr    %cl,%edx
mov    %rsi,%r15
xor    %esi,%esi
nopl   (%rax)
mov    %esi,%ebx
mov    %r11d,%ecx
sar    %cl,%ebx
lea    (%rsi,%r13,1),%eax
imul   %r12d,%ebx
add    %edx,%ebx
movslq %ebx,%rbx
sar    %cl,%eax
movss  (%r10,%rbx,4),%xmm4
imul   %r12d,%eax
add    %edx,%eax
cltq
subss  (%r10,%rax,4),%xmm4
andps  %xmm0,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm2,%xmm5
divsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
movss  %xmm4,(%r8,%rsi,4)
lea    (%rsi,%r14,1),%rax
mov    %rax,%rsi
cmp    %r15,%rax
jl     12d0 <dt_iop_equalizer_iwtf+0x1d0>
mov    %r15,%rsi
mov    -0x78(%rbp),%r15
mov    -0x38(%rbp),%rcx
mov    -0x50(%rbp),%rbx
mov    -0x40(%rbp),%r10
mov    -0x60(%rbp),%rax
add    %ebx,%eax
shl    $0x2,%eax
lea    0x0(,%rbx,4),%r12d
cltq
movss  (%rdi,%r12,4),%xmm4
movss  (%rdi,%rax,4),%xmm5
mulss  %xmm8,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,(%rdi,%r12,4)
lea    0x1(,%rbx,4),%edx
movss  (%rdi,%rdx,4),%xmm4
movss  0x4(%rdi,%rax,4),%xmm5
mulss  %xmm8,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,(%rdi,%rdx,4)
lea    0x2(,%rbx,4),%edx
movss  (%rdi,%rdx,4),%xmm4
movss  0x8(%rdi,%rax,4),%xmm5
mulss  %xmm8,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,(%rdi,%rdx,4)
mov    %r10d,%r13d
cmp    -0x70(%rbp),%r10d
mov    %rbx,-0x50(%rbp)
jge    151d <dt_iop_equalizer_iwtf+0x41d>
mov    -0xc0(%rbp),%rax
lea    (%rax,%rbx,4),%r14d
mov    -0xa0(%rbp),%rax
lea    (%rax,%rbx,1),%r10d
shl    $0x2,%r10d
mov    -0xa8(%rbp),%rax
lea    (%rax,%rbx,1),%edx
shl    $0x2,%edx
mov    -0x98(%rbp),%rax
lea    (%r8,%rax,1),%rcx
mov    %r15,%r13
nopl   0x0(%rax)
movss  (%rcx,%r13,4),%xmm4
movss  (%r8,%r13,4),%xmm5
movaps %xmm4,%xmm6
addss  %xmm5,%xmm6
movslq %r14d,%r14
movslq %r10d,%r10
movslq %edx,%rdx
cvtss2sd %xmm6,%xmm6
movss  (%rdi,%r10,4),%xmm7
mulss  %xmm5,%xmm7
movss  (%rdi,%r14,4),%xmm3
addsd  %xmm6,%xmm6
mulss  %xmm4,%xmm3
addss  %xmm7,%xmm3
cvtss2sd %xmm3,%xmm3
lea    0x0(,%r14,4),%rsi
divsd  %xmm6,%xmm3
movss  (%rdi,%rdx,4),%xmm7
cvtss2sd %xmm7,%xmm7
lea    0x0(,%r10,4),%r15
subsd  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtsd2ss %xmm7,%xmm3
mov    %rsi,%rax
movss  %xmm3,(%rdi,%rdx,4)
or     $0x4,%rax
mov    %r15,%rbx
or     $0x4,%rbx
movss  (%rdi,%rbx,1),%xmm3
mulss  %xmm5,%xmm3
movss  (%rdi,%rax,1),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
lea    0x0(,%rdx,4),%r11
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
divsd  %xmm6,%xmm3
mov    %r11,%rax
or     $0x4,%rax
movss  (%rdi,%rax,1),%xmm7
cvtss2sd %xmm7,%xmm7
subsd  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtsd2ss %xmm7,%xmm3
movss  %xmm3,(%rdi,%rax,1)
or     $0x8,%r15
mulss  (%rdi,%r15,1),%xmm5
mov    -0x78(%rbp),%r15
or     $0x8,%rsi
mulss  (%rdi,%rsi,1),%xmm4
mov    -0x88(%rbp),%rsi
addss  %xmm5,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
divsd  %xmm6,%xmm3
or     $0x8,%r11
movss  (%rdi,%r11,1),%xmm4
cvtss2sd %xmm4,%xmm4
subsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,(%rdi,%r11,1)
add    %r15,%r13
add    %r9d,%r14d
add    %r9d,%r10d
add    %r9d,%edx
cmp    %rsi,%r13
jl     13f0 <dt_iop_equalizer_iwtf+0x2f0>
mov    -0x38(%rbp),%rcx
mov    -0x50(%rbp),%rbx
cmp    -0x30(%rbp),%r13d
jge    1597 <dt_iop_equalizer_iwtf+0x497>
mov    %r13d,%eax
sub    -0x48(%rbp),%eax
mov    -0x58(%rbp),%rcx
imul   %ecx,%eax
add    %ebx,%eax
shl    $0x2,%eax
imul   %ecx,%r13d
add    %ebx,%r13d
shl    $0x2,%r13d
cltq
movslq %r13d,%rcx
movss  (%rdi,%rax,4),%xmm3
mulss  %xmm8,%xmm3
movss  (%rdi,%rcx,4),%xmm4
subss  %xmm3,%xmm4
movss  0x4(%rdi,%rcx,4),%xmm3
movss  %xmm4,(%rdi,%rcx,4)
movss  0x4(%rdi,%rax,4),%xmm4
mulss  %xmm8,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,0x4(%rdi,%rcx,4)
movss  0x8(%rdi,%rcx,4),%xmm3
movss  0x8(%rdi,%rax,4),%xmm4
mulss  %xmm8,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,0x8(%rdi,%rcx,4)
mov    -0x38(%rbp),%rcx
mov    -0x48(%rbp),%rax
mov    %eax,%r11d
cmp    -0x70(%rbp),%eax
mov    -0xb8(%rbp),%r14
mov    -0x80(%rbp),%rdx
mov    -0x40(%rbp),%r13
jge    16b3 <dt_iop_equalizer_iwtf+0x5b3>
lea    (%r8,%r14,4),%r10
mov    -0x48(%rbp),%rax
mov    %eax,%r11d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r8,%rbx,4),%xmm4
lea    (%rcx,%r12,1),%eax
movss  (%r10,%rbx,4),%xmm6
movaps %xmm4,%xmm5
lea    (%rdx,%r12,1),%ecx
movslq %r12d,%r12
movslq %eax,%rdx
addss  %xmm6,%xmm5
movslq %ecx,%rax
lea    0x0(,%r12,4),%rsi
movss  (%rdi,%rdx,4),%xmm3
mulss  %xmm6,%xmm3
movss  (%rdi,%r12,4),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
shl    $0x2,%rdx
divss  %xmm5,%xmm7
addss  (%rdi,%rax,4),%xmm7
mov    %rdx,%rcx
movss  %xmm7,(%rdi,%rax,4)
or     $0x4,%rcx
movss  (%rdi,%rcx,1),%xmm3
mov    %rsi,%rcx
or     $0x4,%rcx
mulss  %xmm6,%xmm3
movss  (%rdi,%rcx,1),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
lea    0x0(,%rax,4),%rax
divss  %xmm5,%xmm7
mov    %rax,%rcx
or     $0x4,%rcx
addss  (%rdi,%rcx,1),%xmm7
movss  %xmm7,(%rdi,%rcx,1)
mov    -0x38(%rbp),%rcx
or     $0x8,%rdx
mulss  (%rdi,%rdx,1),%xmm6
mov    -0x80(%rbp),%rdx
or     $0x8,%rsi
mulss  (%rdi,%rsi,1),%xmm4
mov    -0x88(%rbp),%rsi
addss  %xmm6,%xmm4
divss  %xmm5,%xmm4
or     $0x8,%rax
addss  (%rdi,%rax,1),%xmm4
add    %r9d,%r12d
movss  %xmm4,(%rdi,%rax,1)
add    %r15,%rbx
add    %r13d,%r11d
lea    (%r14,%rbx,1),%rax
cmp    %rsi,%rax
jl     15d0 <dt_iop_equalizer_iwtf+0x4d0>
cmp    -0x30(%rbp),%r11d
mov    -0x50(%rbp),%rbx
mov    -0x48(%rbp),%r13
jge    1260 <dt_iop_equalizer_iwtf+0x160>
mov    %r11d,%eax
sub    %r13d,%eax
mov    -0x58(%rbp),%rcx
imul   %ecx,%eax
add    %ebx,%eax
shl    $0x2,%eax
imul   %ecx,%r11d
add    %ebx,%r11d
shl    $0x2,%r11d
cltq
movslq %r11d,%rcx
movss  (%rdi,%rax,4),%xmm3
addss  (%rdi,%rcx,4),%xmm3
movss  %xmm3,(%rdi,%rcx,4)
movss  0x4(%rdi,%rax,4),%xmm3
addss  0x4(%rdi,%rcx,4),%xmm3
movss  %xmm3,0x4(%rdi,%rcx,4)
movss  0x8(%rdi,%rax,4),%xmm3
addss  0x8(%rdi,%rcx,4),%xmm3
movss  %xmm3,0x8(%rdi,%rcx,4)
mov    -0x38(%rbp),%rcx
jmp    1260 <dt_iop_equalizer_iwtf+0x160>
cmpl   $0x0,-0x30(%rbp)
jle    1d04 <dt_iop_equalizer_iwtf+0xc04>
mov    -0x40(%rbp),%rax
movslq %eax,%rdx
mov    -0x58(%rbp),%rcx
mov    %ecx,%r8d
sub    %r13d,%r8d
movslq %r8d,%r12
lea    0x0(,%rax,4),%esi
lea    0x0(,%rcx,4),%ecx
mov    %ecx,-0xcc(%rbp)
mov    %rdx,%rcx
add    %r13d,%eax
shl    $0x2,%eax
mov    %eax,-0xa0(%rbp)
lea    0x0(,%r13,4),%edx
mov    %edx,%r14d
neg    %r14d
lea    0x0(,%rcx,4),%r9
lea    0x0(,%r10,4),%r15
neg    %r15
lea    0x0(,%r13,8),%ebx
xor    %eax,%eax
mov    %rax,-0x60(%rbp)
mov    -0xc8(%rbp),%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,-0xf0(%rbp)
movaps 0x84c(%rip),%xmm0
movsd  0x854(%rip),%xmm1
movsd  0x854(%rip),%xmm2
movss  0x853(%rip),%xmm8
mov    %esi,-0x98(%rbp)
xor    %eax,%eax
mov    %rax,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8d,-0x68(%rbp)
mov    %esi,-0x50(%rbp)
mov    %rdx,-0x80(%rbp)
mov    %r14,-0x108(%rbp)
mov    %r9,-0x100(%rbp)
mov    %r15,-0xf8(%rbp)
mov    %rbx,-0x78(%rbp)
mov    %r12,-0xb0(%rbp)
jmp    187d <dt_iop_equalizer_iwtf+0x77d>
nopw   0x0(%rax,%rax,1)
mov    -0xc0(%rbp),%rsp
mov    -0x30(%rbp),%r8
add    $0x1,%r8
mov    -0xcc(%rbp),%eax
add    %eax,-0x98(%rbp)
add    %eax,-0xa0(%rbp)
mov    -0x60(%rbp),%rcx
add    %eax,%ecx
mov    %rcx,-0x60(%rbp)
mov    %r8,%rax
mov    %r8,-0x30(%rbp)
cmp    -0xd8(%rbp),%r8
mov    -0x90(%rbp),%r11d
mov    -0xb8(%rbp),%r10
mov    -0x68(%rbp),%r8d
mov    -0x108(%rbp),%r14
mov    -0x100(%rbp),%r9
mov    -0xf8(%rbp),%r15
mov    -0xb0(%rbp),%r12
je     1d04 <dt_iop_equalizer_iwtf+0xc04>
mov    %rsp,-0xc0(%rbp)
mov    %rsp,%rdx
sub    -0xf0(%rbp),%rdx
mov    %rdx,%rsp
test   %r8d,%r8d
mov    %rdx,-0x88(%rbp)
jle    1921 <dt_iop_equalizer_iwtf+0x821>
mov    -0x30(%rbp),%rax
mov    %r11d,%ecx
shr    %cl,%eax
mov    -0xe8(%rbp),%rcx
mov    -0xe0(%rbp),%rdx
mov    (%rcx,%rdx,8),%r8
imul   -0x8c(%rbp),%eax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsi,%r13,1),%ebx
mov    %esi,%edx
mov    %r11d,%ecx
sar    %cl,%edx
add    %eax,%edx
sar    %cl,%ebx
movslq %edx,%rcx
movss  (%r8,%rcx,4),%xmm4
add    %eax,%ebx
movslq %ebx,%rcx
mov    -0x88(%rbp),%rdx
subss  (%r8,%rcx,4),%xmm4
andps  %xmm0,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm2,%xmm5
divsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
movss  %xmm4,(%rdx,%rsi,4)
add    %r10,%rsi
cmp    %r12,%rsi
jl     18d0 <dt_iop_equalizer_iwtf+0x7d0>
mov    -0x30(%rbp),%rax
mov    %eax,%ecx
imul   -0xc8(%rbp),%ecx
lea    (%rcx,%r13,1),%eax
shl    $0x2,%eax
mov    %rcx,-0xa8(%rbp)
lea    0x0(,%rcx,4),%ecx
cltq
movslq %ecx,%rcx
movss  (%rdi,%rax,4),%xmm4
mulss  %xmm8,%xmm4
movss  (%rdi,%rcx,4),%xmm5
subss  %xmm4,%xmm5
movss  0x4(%rdi,%rcx,4),%xmm4
movss  %xmm5,(%rdi,%rcx,4)
movss  0x4(%rdi,%rax,4),%xmm5
mulss  %xmm8,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,0x4(%rdi,%rcx,4)
movss  0x8(%rdi,%rcx,4),%xmm4
movss  0x8(%rdi,%rax,4),%xmm5
mulss  %xmm8,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,0x8(%rdi,%rcx,4)
mov    -0x40(%rbp),%rax
mov    %eax,%r10d
mov    -0x68(%rbp),%esi
cmp    %esi,%eax
mov    -0x38(%rbp),%rcx
jge    1aff <dt_iop_equalizer_iwtf+0x9ff>
lea    (%rdx,%rcx,4),%r11
mov    -0xa0(%rbp),%eax
mov    %eax,%r8d
mov    -0x98(%rbp),%eax
mov    %eax,%ebx
mov    %rcx,%r10
mov    %r15,%r13
mov    %r9,%r15
mov    %r14,%r9
mov    -0x50(%rbp),%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r11,%r13,1),%xmm4
lea    (%r9,%rbx,1),%eax
movss  (%r11),%xmm5
movaps %xmm4,%xmm6
addss  %xmm5,%xmm6
cltq
movslq %r8d,%r8
movslq %ebx,%rbx
cvtss2sd %xmm6,%xmm6
movss  (%rdi,%r8,4),%xmm7
mulss  %xmm5,%xmm7
movss  (%rdi,%rax,4),%xmm3
addsd  %xmm6,%xmm6
mulss  %xmm4,%xmm3
addss  %xmm7,%xmm3
cvtss2sd %xmm3,%xmm3
lea    0x0(,%r8,4),%rdx
divsd  %xmm6,%xmm3
movss  (%rdi,%rbx,4),%xmm7
cvtss2sd %xmm7,%xmm7
shl    $0x2,%rax
subsd  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtsd2ss %xmm7,%xmm3
mov    %rax,%rcx
movss  %xmm3,(%rdi,%rbx,4)
or     $0x4,%rcx
mov    %rdx,%rsi
or     $0x4,%rsi
movss  (%rdi,%rsi,1),%xmm3
mulss  %xmm5,%xmm3
movss  (%rdi,%rcx,1),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
lea    0x0(,%rbx,4),%rsi
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
divsd  %xmm6,%xmm3
mov    %rsi,%rcx
or     $0x4,%rcx
movss  (%rdi,%rcx,1),%xmm7
cvtss2sd %xmm7,%xmm7
subsd  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtsd2ss %xmm7,%xmm3
movss  %xmm3,(%rdi,%rcx,1)
mov    -0x38(%rbp),%rcx
or     $0x8,%rdx
mulss  (%rdi,%rdx,1),%xmm5
or     $0x8,%rax
mulss  (%rdi,%rax,1),%xmm4
addss  %xmm5,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
divsd  %xmm6,%xmm3
or     $0x8,%rsi
movss  (%rdi,%rsi,1),%xmm4
cvtss2sd %xmm4,%xmm4
subsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,(%rdi,%rsi,1)
add    %rcx,%r10
add    %r14d,%ebx
add    %r14d,%r8d
add    %r15,%r11
cmp    %r12,%r10
jl     19e0 <dt_iop_equalizer_iwtf+0x8e0>
mov    -0x48(%rbp),%r13
mov    -0x68(%rbp),%esi
cmp    -0x58(%rbp),%r10d
jge    1b71 <dt_iop_equalizer_iwtf+0xa71>
mov    -0xa8(%rbp),%rcx
mov    %ecx,%eax
sub    %r13d,%eax
add    %r10d,%eax
shl    $0x2,%eax
add    %ecx,%r10d
shl    $0x2,%r10d
cltq
movslq %r10d,%rcx
movss  (%rdi,%rax,4),%xmm3
mulss  %xmm8,%xmm3
movss  (%rdi,%rcx,4),%xmm4
subss  %xmm3,%xmm4
movss  0x4(%rdi,%rcx,4),%xmm3
movss  %xmm4,(%rdi,%rcx,4)
movss  0x4(%rdi,%rax,4),%xmm4
mulss  %xmm8,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,0x4(%rdi,%rcx,4)
movss  0x8(%rdi,%rcx,4),%xmm3
movss  0x8(%rdi,%rax,4),%xmm4
mulss  %xmm8,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,0x8(%rdi,%rcx,4)
mov    %r13d,%r10d
cmp    %esi,%r13d
mov    -0x40(%rbp),%r13
mov    -0xb8(%rbp),%r15
mov    -0x38(%rbp),%r9
mov    -0x80(%rbp),%rdx
mov    -0x78(%rbp),%rbx
mov    -0x88(%rbp),%r12
mov    -0xb0(%rbp),%r8
jge    1ca0 <dt_iop_equalizer_iwtf+0xba0>
lea    (%r12,%r15,4),%rax
mov    %rax,-0x70(%rbp)
mov    -0x48(%rbp),%rax
mov    %eax,%r10d
xor    %r14d,%r14d
mov    -0x60(%rbp),%rax
nopl   0x0(%rax,%rax,1)
movss  (%r12,%r14,4),%xmm4
lea    (%rbx,%rax,1),%ecx
mov    -0x70(%rbp),%rsi
movss  (%rsi,%r14,4),%xmm6
movaps %xmm4,%xmm5
lea    (%rdx,%rax,1),%ebx
cltq
movslq %ecx,%rsi
addss  %xmm6,%xmm5
movslq %ebx,%r11
lea    0x0(,%rax,4),%rbx
movss  (%rdi,%rsi,4),%xmm3
mulss  %xmm6,%xmm3
movss  (%rdi,%rax,4),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
shl    $0x2,%rsi
divss  %xmm5,%xmm7
addss  (%rdi,%r11,4),%xmm7
mov    %rsi,%rcx
movss  %xmm7,(%rdi,%r11,4)
or     $0x4,%rcx
movss  (%rdi,%rcx,1),%xmm3
mov    %rbx,%rcx
or     $0x4,%rcx
mulss  %xmm6,%xmm3
movss  (%rdi,%rcx,1),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
lea    0x0(,%r11,4),%rdx
divss  %xmm5,%xmm7
mov    %rdx,%rcx
or     $0x4,%rcx
addss  (%rdi,%rcx,1),%xmm7
movss  %xmm7,(%rdi,%rcx,1)
or     $0x8,%rsi
mulss  (%rdi,%rsi,1),%xmm6
mov    -0x50(%rbp),%esi
or     $0x8,%rbx
mulss  (%rdi,%rbx,1),%xmm4
mov    -0x78(%rbp),%rbx
addss  %xmm6,%xmm4
divss  %xmm5,%xmm4
or     $0x8,%rdx
addss  (%rdi,%rdx,1),%xmm4
add    %esi,%eax
movss  %xmm4,(%rdi,%rdx,1)
mov    -0x80(%rbp),%rdx
add    %r9,%r14
add    %r13d,%r10d
lea    (%r15,%r14,1),%rcx
cmp    %r8,%rcx
jl     1bc0 <dt_iop_equalizer_iwtf+0xac0>
cmp    -0x58(%rbp),%r10d
mov    -0x48(%rbp),%r13
jge    1810 <dt_iop_equalizer_iwtf+0x710>
mov    -0xa8(%rbp),%rcx
mov    %ecx,%eax
sub    %r13d,%eax
add    %r10d,%eax
shl    $0x2,%eax
add    %ecx,%r10d
shl    $0x2,%r10d
cltq
movslq %r10d,%rcx
movss  (%rdi,%rax,4),%xmm3
addss  (%rdi,%rcx,4),%xmm3
movss  %xmm3,(%rdi,%rcx,4)
movss  0x4(%rdi,%rax,4),%xmm3
addss  0x4(%rdi,%rcx,4),%xmm3
movss  %xmm3,0x4(%rdi,%rcx,4)
movss  0x8(%rdi,%rax,4),%xmm3
addss  0x8(%rdi,%rcx,4),%xmm3
movss  %xmm3,0x8(%rdi,%rcx,4)
jmp    1810 <dt_iop_equalizer_iwtf+0x710>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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