void dt_iop_equalizer_wtf(float *buf, float **weight_a, const int l,
                          const int width, const int height) {
  const int wd = (int)(1 + (width >> (l - 1))),
            ht = (int)(1 + (height >> (l - 1)));
  int ch = 0;
  memset(weight_a[l], 0, sizeof(float) * wd * ht);
  for (int j = 0; j < ht - 1; j++)
    for (int i = 0; i < wd - 1; i++)
      weight_a[l][j * wd + i] =
          ((buf)[4 * (width * ((j << (l - 1))) + ((i << (l - 1)))) + ch]);
  const int step = 1 << l;
  const int st = step / 2;
  for (int j = 0; j < height; j++) {
    float tmp[width];
    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);
    int i = st;
    for (; i < width - st; i += step)
      for (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 (ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) -=
            ((buf)[4 * (width * ((j)) + ((i - st))) + ch]);
    for (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 (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 (ch = 0; ch < 3; ch++)
        ((buf)[4 * (width * ((j)) + ((i))) + ch]) +=
            ((buf)[4 * (width * ((j)) + ((i - st))) + ch]) * .5f;
  }
  for (int i = 0; i < width; i++) {
    float tmp[height];
    for (int 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);
    int j = st;
    for (; j < height - st; j += step)
      for (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 (ch = 0; ch < 3; ch++)
      ((buf)[4 * (width * ((0)) + ((i))) + ch]) +=
          ((buf)[4 * (width * ((st)) + ((i))) + ch]) * 0.5;
    for (j = step; j < height - st; j += step)
      for (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;
  }
}


x86 assembly (clang, -O0):
<dt_iop_equalizer_wtf>:
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    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x20(%rbp),%rdx
shl    $0x2,%rdx
movslq -0x24(%rbp),%rax
imul   %rax,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1230 <dt_iop_equalizer_wtf+0x120>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    121d <dt_iop_equalizer_wtf+0x10d>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,-0x88(%rbp)
mov    -0x2c(%rbp),%edx
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%edx
mov    -0x88(%rbp),%ecx
imul   %edx,%ecx
mov    %ecx,-0x84(%rbp)
mov    -0x30(%rbp),%edx
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%edx
mov    -0x84(%rbp),%ecx
add    %edx,%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1198 <dt_iop_equalizer_wtf+0x88>
jmp    1222 <dt_iop_equalizer_wtf+0x112>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1180 <dt_iop_equalizer_wtf+0x70>
mov    -0x14(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16e7 <dt_iop_equalizer_wtf+0x5d7>
mov    -0x18(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x48(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x90(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    1370 <dt_iop_equalizer_wtf+0x260>
mov    -0x90(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %rcx,-0xa0(%rbp)
mov    -0x20(%rbp),%edx
mov    -0x3c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x54(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0xa0(%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,-0x98(%rbp)
mov    -0x20(%rbp),%edx
mov    -0x3c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x54(%rbp),%esi
add    -0x38(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0x98(%rbp),%rcx
add    %esi,%edx
movslq %edx,%rdx
subss  (%rcx,%rdx,4),%xmm0
movaps 0xcfb(%rip),%xmm1
pand   %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcdb(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0xcc7(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    128f <dt_iop_equalizer_wtf+0x17f>
mov    -0x38(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    1461 <dt_iop_equalizer_wtf+0x351>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    144e <dt_iop_equalizer_wtf+0x33e>
mov    -0x90(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x3c(%rbp),%edx
mov    -0x58(%rbp),%esi
sub    -0x38(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x3c(%rbp),%edx
mov    -0x58(%rbp),%esi
add    -0x38(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x58(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
divss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x58(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    138e <dt_iop_equalizer_wtf+0x27e>
jmp    1453 <dt_iop_equalizer_wtf+0x343>
mov    -0x34(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    1376 <dt_iop_equalizer_wtf+0x266>
mov    -0x58(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    14d7 <dt_iop_equalizer_wtf+0x3c7>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    14d2 <dt_iop_equalizer_wtf+0x3c2>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
mov    -0x58(%rbp),%edx
sub    -0x38(%rbp),%edx
add    %edx,%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x58(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1474 <dt_iop_equalizer_wtf+0x364>
jmp    14d7 <dt_iop_equalizer_wtf+0x3c7>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1543 <dt_iop_equalizer_wtf+0x433>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0xad8(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14de <dt_iop_equalizer_wtf+0x3ce>
mov    -0x34(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    1650 <dt_iop_equalizer_wtf+0x540>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    163d <dt_iop_equalizer_wtf+0x52d>
mov    -0x90(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x3c(%rbp),%edx
mov    -0x58(%rbp),%esi
sub    -0x38(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x3c(%rbp),%edx
mov    -0x58(%rbp),%esi
add    -0x38(%rbp),%esi
add    %esi,%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x58(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xa0e(%rip),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x58(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1561 <dt_iop_equalizer_wtf+0x451>
jmp    1642 <dt_iop_equalizer_wtf+0x532>
mov    -0x34(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    1549 <dt_iop_equalizer_wtf+0x439>
mov    -0x58(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16d2 <dt_iop_equalizer_wtf+0x5c2>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    16cd <dt_iop_equalizer_wtf+0x5bd>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
mov    -0x58(%rbp),%edx
sub    -0x38(%rbp),%edx
add    %edx,%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x58(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x94e(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1663 <dt_iop_equalizer_wtf+0x553>
jmp    16d2 <dt_iop_equalizer_wtf+0x5c2>
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1252 <dt_iop_equalizer_wtf+0x142>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b8c <dt_iop_equalizer_wtf+0xa7c>
mov    -0x1c(%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,-0xa8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    180c <dt_iop_equalizer_wtf+0x6fc>
mov    -0xa8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %rcx,-0xb8(%rbp)
mov    -0x20(%rbp),%edx
mov    -0x74(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x5c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0xb8(%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,-0xb0(%rbp)
mov    -0x20(%rbp),%edx
mov    -0x74(%rbp),%esi
add    -0x38(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    %esi,%ecx
imul   %ecx,%edx
mov    -0x5c(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sar    %cl,%esi
mov    -0xb0(%rbp),%rcx
add    %esi,%edx
movslq %edx,%rdx
subss  (%rcx,%rdx,4),%xmm0
movaps 0x85f(%rip),%xmm1
pand   %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x83f(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x82b(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    172b <dt_iop_equalizer_wtf+0x61b>
mov    -0x38(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    18fd <dt_iop_equalizer_wtf+0x7ed>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    18ea <dt_iop_equalizer_wtf+0x7da>
mov    -0xa8(%rbp),%rax
mov    -0x78(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x78(%rbp),%esi
sub    -0x38(%rbp),%esi
imul   %esi,%edx
add    -0x5c(%rbp),%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x78(%rbp),%esi
add    -0x38(%rbp),%esi
imul   %esi,%edx
add    -0x5c(%rbp),%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x78(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x78(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
divss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    182a <dt_iop_equalizer_wtf+0x71a>
jmp    18ef <dt_iop_equalizer_wtf+0x7df>
mov    -0x34(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    1812 <dt_iop_equalizer_wtf+0x702>
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1973 <dt_iop_equalizer_wtf+0x863>
movl   $0x0,-0x7c(%rbp)
cmpl   $0x3,-0x7c(%rbp)
jge    196e <dt_iop_equalizer_wtf+0x85e>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x78(%rbp),%edx
sub    -0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1910 <dt_iop_equalizer_wtf+0x800>
jmp    1973 <dt_iop_equalizer_wtf+0x863>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    19e8 <dt_iop_equalizer_wtf+0x8d8>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x0,-0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x647(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    197a <dt_iop_equalizer_wtf+0x86a>
mov    -0x34(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    1af5 <dt_iop_equalizer_wtf+0x9e5>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1ae2 <dt_iop_equalizer_wtf+0x9d2>
mov    -0xa8(%rbp),%rax
mov    -0x78(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x78(%rbp),%esi
sub    -0x38(%rbp),%esi
imul   %esi,%edx
add    -0x5c(%rbp),%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
mov    -0x78(%rbp),%esi
add    -0x38(%rbp),%esi
imul   %esi,%edx
add    -0x5c(%rbp),%edx
shl    $0x2,%edx
add    -0x28(%rbp),%edx
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x78(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x78(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0x569(%rip),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a06 <dt_iop_equalizer_wtf+0x8f6>
jmp    1ae7 <dt_iop_equalizer_wtf+0x9d7>
mov    -0x34(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    19ee <dt_iop_equalizer_wtf+0x8de>
mov    -0x78(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b77 <dt_iop_equalizer_wtf+0xa67>
movl   $0x0,-0x80(%rbp)
cmpl   $0x3,-0x80(%rbp)
jge    1b72 <dt_iop_equalizer_wtf+0xa62>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x78(%rbp),%edx
sub    -0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x4a9(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1b08 <dt_iop_equalizer_wtf+0x9f8>
jmp    1b77 <dt_iop_equalizer_wtf+0xa67>
mov    -0x68(%rbp),%rax
mov    %rax,%rsp
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    16ee <dt_iop_equalizer_wtf+0x5de>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dt_iop_equalizer_wtf>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
lea    -0x1(%rdx),%ebx
mov    %rcx,-0x40(%rbp)
mov    %ecx,%r14d
mov    %ebx,%ecx
sar    %cl,%r14d
mov    %rdi,%r13
mov    %r8d,-0x44(%rbp)
mov    %r8d,%r12d
mov    %ebx,-0x2c(%rbp)
sar    %cl,%r12d
lea    0x1(%r14),%ecx
lea    0x1(%r12),%eax
mov    %rdx,-0x60(%rbp)
movslq %edx,%rdx
mov    %rsi,-0xe8(%rbp)
mov    %rdx,-0xe0(%rbp)
mov    (%rsi,%rdx,8),%rdi
mov    %ecx,-0x64(%rbp)
movslq %ecx,%rbx
movslq %eax,%rdx
imul   %rbx,%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
test   %r12d,%r12d
jle    128a <dt_iop_equalizer_wtf+0x17a>
mov    %r12d,%r15d
mov    %r14d,%r9d
mov    %r9d,%esi
and    $0xfffffffe,%esi
mov    $0x1,%r11d
xor    %r12d,%r12d
mov    %rbx,-0x38(%rbp)
mov    -0x2c(%rbp),%r8d
jmp    11c0 <dt_iop_equalizer_wtf+0xb0>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
add    %rbx,%r11
cmp    %r15,%r12
je     128a <dt_iop_equalizer_wtf+0x17a>
test   %r14d,%r14d
jle    11b0 <dt_iop_equalizer_wtf+0xa0>
mov    %r12d,%eax
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
imul   -0x40(%rbp),%eax
mov    -0xe8(%rbp),%rcx
mov    -0xe0(%rbp),%rdx
mov    (%rcx,%rdx,8),%r10
cmp    $0x1,%r14d
jne    1200 <dt_iop_equalizer_wtf+0xf0>
xor    %edi,%edi
test   $0x1,%r9b
je     11b0 <dt_iop_equalizer_wtf+0xa0>
jmp    125f <dt_iop_equalizer_wtf+0x14f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r10,%r11,4),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    %edi,%ebx
mov    %r8d,%ecx
shl    %cl,%ebx
add    %eax,%ebx
shl    $0x2,%ebx
movslq %ebx,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
lea    0x1(%rdi),%ebx
mov    %r8d,%ecx
shl    %cl,%ebx
movss  %xmm0,-0x4(%rdx,%rdi,4)
add    %eax,%ebx
shl    $0x2,%ebx
movslq %ebx,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x2,%rdi
cmp    %rsi,%rdi
jne    1210 <dt_iop_equalizer_wtf+0x100>
mov    -0x38(%rbp),%rbx
test   $0x1,%r9b
je     11b0 <dt_iop_equalizer_wtf+0xa0>
mov    %edi,%edx
mov    -0x2c(%rbp),%ecx
shl    %cl,%edx
mov    %r12,%rcx
imul   %rbx,%rcx
add    %eax,%edx
shl    $0x2,%edx
movslq %edx,%rax
movss  0x0(%r13,%rax,4),%xmm0
add    %rdi,%rcx
movss  %xmm0,(%r10,%rcx,4)
jmp    11b0 <dt_iop_equalizer_wtf+0xa0>
mov    $0x1,%eax
mov    -0x60(%rbp),%rcx
shl    %cl,%eax
mov    %eax,%r9d
shr    $0x1f,%r9d
mov    %rax,-0x88(%rbp)
add    %eax,%r9d
sar    %r9d
mov    -0x40(%rbp),%eax
mov    %rax,-0xf8(%rbp)
movslq %r9d,%r14
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,-0xa0(%rbp)
test   %eax,%eax
mov    -0x2c(%rbp),%ecx
mov    %r9,-0x58(%rbp)
mov    %r14,-0x38(%rbp)
jle    18b1 <dt_iop_equalizer_wtf+0x7a1>
mov    -0x40(%rbp),%rax
mov    %eax,%r8d
sub    %r14d,%r8d
movslq %r8d,%r10
mov    -0x88(%rbp),%rdx
movslq %edx,%rsi
lea    0x0(,%r14,4),%edi
lea    0x0(,%rax,4),%eax
mov    %eax,-0xc8(%rbp)
lea    0x0(,%rdx,4),%r11d
lea    0x0(,%r14,8),%ebx
lea    (%rdx,%r9,1),%eax
shl    $0x2,%eax
mov    %eax,-0xb0(%rbp)
mov    %edi,%edx
neg    %edx
mov    %rsi,-0x80(%rbp)
lea    0x0(,%rsi,4),%rsi
lea    0x0(,%r14,4),%r12
neg    %r12
xor    %eax,%eax
mov    %rax,-0x50(%rbp)
mov    -0xf8(%rbp),%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,-0x100(%rbp)
movaps 0xca0(%rip),%xmm0
movsd  0xca8(%rip),%xmm1
movsd  0xca8(%rip),%xmm2
movss  0xcaf(%rip),%xmm8
mov    %r11d,-0xb8(%rbp)
mov    %r11d,-0xa8(%rbp)
xor    %r11d,%r11d
mov    %r8d,-0xd8(%rbp)
mov    %rdi,-0xd0(%rbp)
mov    %rbx,-0xc0(%rbp)
mov    %rdx,-0x90(%rbp)
mov    %rsi,-0x78(%rbp)
mov    %r12,-0x108(%rbp)
jmp    13f8 <dt_iop_equalizer_wtf+0x2e8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xf0(%rbp),%rsp
add    $0x1,%r11
mov    -0xc8(%rbp),%eax
mov    -0x50(%rbp),%rdi
add    %eax,%edi
mov    %rdi,-0x50(%rbp)
add    %eax,-0xa8(%rbp)
add    %eax,-0xb0(%rbp)
cmp    -0xa0(%rbp),%r11
mov    -0x38(%rbp),%r14
je     18b1 <dt_iop_equalizer_wtf+0x7a1>
mov    %rsp,-0xf0(%rbp)
mov    %rsp,%r12
sub    -0x100(%rbp),%r12
mov    %r12,%rsp
test   %r8d,%r8d
jle    1476 <dt_iop_equalizer_wtf+0x366>
mov    %r11d,%eax
shr    %cl,%eax
mov    -0xe8(%rbp),%rdx
mov    -0xe0(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
imul   -0x64(%rbp),%eax
xor    %esi,%esi
xchg   %ax,%ax
lea    (%r9,%rsi,1),%edi
mov    %esi,%ebx
sar    %cl,%ebx
add    %eax,%ebx
sar    %cl,%edi
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm4
add    %eax,%edi
movslq %edi,%rdi
subss  (%rdx,%rdi,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,(%r12,%rsi,4)
add    %r14,%rsi
cmp    %r10,%rsi
jl     1430 <dt_iop_equalizer_wtf+0x320>
mov    %r11,-0x70(%rbp)
mov    %r9d,%ecx
cmp    %r8d,%r9d
mov    -0x88(%rbp),%r11
mov    -0x80(%rbp),%r8
mov    %r12,-0x60(%rbp)
mov    -0xd0(%rbp),%r12
mov    -0xb8(%rbp),%r15d
mov    -0xc0(%rbp),%r14
jge    15d3 <dt_iop_equalizer_wtf+0x4c3>
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x98(%rbp)
mov    -0x58(%rbp),%rax
mov    %eax,%ecx
xor    %edi,%edi
mov    -0x50(%rbp),%rdx
nopl   0x0(%rax)
mov    -0x60(%rbp),%rax
movss  (%rax,%rdi,4),%xmm4
lea    (%r14,%rdx,1),%eax
mov    -0x98(%rbp),%rsi
movss  (%rsi,%rdi,4),%xmm6
movaps %xmm4,%xmm5
lea    (%r12,%rdx,1),%esi
movslq %edx,%rdx
movslq %eax,%r9
addss  %xmm6,%xmm5
movslq %esi,%rbx
lea    0x0(,%rdx,4),%rsi
movss  0x0(%r13,%r9,4),%xmm7
mulss  %xmm6,%xmm7
movss  0x0(%r13,%rdx,4),%xmm3
mulss  %xmm4,%xmm3
addss  %xmm7,%xmm3
shl    $0x2,%r9
divss  %xmm5,%xmm3
movss  0x0(%r13,%rbx,4),%xmm7
subss  %xmm3,%xmm7
mov    %r9,%rax
movss  %xmm7,0x0(%r13,%rbx,4)
or     $0x4,%rax
movss  0x0(%r13,%rax,1),%xmm3
mov    %rsi,%rax
or     $0x4,%rax
mulss  %xmm6,%xmm3
movss  0x0(%r13,%rax,1),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
lea    0x0(,%rbx,4),%rbx
divss  %xmm5,%xmm7
mov    %rbx,%rax
or     $0x4,%rax
movss  0x0(%r13,%rax,1),%xmm3
subss  %xmm7,%xmm3
movss  %xmm3,0x0(%r13,%rax,1)
or     $0x8,%r9
mulss  0x0(%r13,%r9,1),%xmm6
or     $0x8,%rsi
mulss  0x0(%r13,%rsi,1),%xmm4
addss  %xmm6,%xmm4
divss  %xmm5,%xmm4
or     $0x8,%rbx
movss  0x0(%r13,%rbx,1),%xmm3
subss  %xmm4,%xmm3
add    %r15d,%edx
movss  %xmm3,0x0(%r13,%rbx,1)
add    %r8,%rdi
add    %r11d,%ecx
mov    -0x38(%rbp),%rax
add    %rdi,%rax
cmp    %r10,%rax
jl     14d0 <dt_iop_equalizer_wtf+0x3c0>
mov    -0x70(%rbp),%r11
mov    %r11,%rdi
imul   -0xf8(%rbp),%rdi
ff
cmp    -0x40(%rbp),%ecx
mov    -0x58(%rbp),%r9
jge    163e <dt_iop_equalizer_wtf+0x52e>
mov    %edi,%eax
sub    %r9d,%eax
add    %ecx,%eax
shl    $0x2,%eax
add    %edi,%ecx
shl    $0x2,%ecx
cltq
movslq %ecx,%rcx
movss  0x0(%r13,%rcx,4),%xmm3
movss  0x4(%r13,%rcx,4),%xmm4
subss  0x0(%r13,%rax,4),%xmm3
movss  %xmm3,0x0(%r13,%rcx,4)
subss  0x4(%r13,%rax,4),%xmm4
movss  %xmm4,0x4(%r13,%rcx,4)
movss  0x8(%r13,%rcx,4),%xmm3
subss  0x8(%r13,%rax,4),%xmm3
movss  %xmm3,0x8(%r13,%rcx,4)
mov    %edi,%eax
add    %r9d,%eax
shl    $0x2,%eax
lea    0x0(,%rdi,4),%ecx
cltq
movslq %ecx,%rcx
movss  0x0(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x0(%r13,%rcx,4),%xmm3
movss  %xmm3,0x0(%r13,%rcx,4)
movss  0x4(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x4(%r13,%rcx,4),%xmm3
movss  %xmm3,0x4(%r13,%rcx,4)
movss  0x8(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x8(%r13,%rcx,4),%xmm3
movss  %xmm3,0x8(%r13,%rcx,4)
mov    -0x88(%rbp),%rax
mov    %eax,%r14d
mov    -0xd8(%rbp),%r8d
cmp    %r8d,%eax
mov    -0x108(%rbp),%r12
jge    183a <dt_iop_equalizer_wtf+0x72a>
mov    %rdi,-0x98(%rbp)
mov    -0x80(%rbp),%r11
mov    -0x60(%rbp),%rax
lea    (%rax,%r11,4),%r9
mov    -0xb0(%rbp),%eax
mov    -0xa8(%rbp),%ecx
mov    %ecx,%edi
mov    %r11,%r14
mov    -0xb8(%rbp),%r15d
nopl   0x0(%rax)
movss  (%r9,%r12,1),%xmm4
mov    -0x90(%rbp),%rcx
lea    (%rcx,%rdi,1),%edx
movss  (%r9),%xmm5
movaps %xmm4,%xmm3
addss  %xmm5,%xmm3
movslq %edx,%rcx
cltq
movslq %edi,%rdi
xorps  %xmm6,%xmm6
cvtss2sd %xmm3,%xmm6
movss  0x0(%r13,%rax,4),%xmm3
mulss  %xmm5,%xmm3
movss  0x0(%r13,%rcx,4),%xmm7
addsd  %xmm6,%xmm6
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
lea    0x0(,%rax,4),%rsi
divsd  %xmm6,%xmm3
movss  0x0(%r13,%rdi,4),%xmm7
cvtss2sd %xmm7,%xmm7
shl    $0x2,%rcx
addsd  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtsd2ss %xmm7,%xmm3
mov    %rcx,%rdx
movss  %xmm3,0x0(%r13,%rdi,4)
or     $0x4,%rdx
mov    %rsi,%rbx
or     $0x4,%rbx
movss  0x0(%r13,%rbx,1),%xmm3
mulss  %xmm5,%xmm3
movss  0x0(%r13,%rdx,1),%xmm7
mulss  %xmm4,%xmm7
addss  %xmm3,%xmm7
lea    0x0(,%rdi,4),%rbx
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
divsd  %xmm6,%xmm3
mov    %rbx,%rdx
or     $0x4,%rdx
movss  0x0(%r13,%rdx,1),%xmm7
cvtss2sd %xmm7,%xmm7
addsd  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtsd2ss %xmm7,%xmm3
movss  %xmm3,0x0(%r13,%rdx,1)
or     $0x8,%rsi
mulss  0x0(%r13,%rsi,1),%xmm5
mov    -0x78(%rbp),%rsi
or     $0x8,%rcx
mulss  0x0(%r13,%rcx,1),%xmm4
addss  %xmm5,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
divsd  %xmm6,%xmm3
or     $0x8,%rbx
movss  0x0(%r13,%rbx,1),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,0x0(%r13,%rbx,1)
add    %r11,%r14
add    %r15d,%edi
add    %r15d,%eax
add    %rsi,%r9
cmp    %r10,%r14
jl     16f0 <dt_iop_equalizer_wtf+0x5e0>
mov    -0x58(%rbp),%r9
mov    -0x70(%rbp),%r11
mov    -0x98(%rbp),%rdi
cmp    -0x40(%rbp),%r14d
mov    -0x2c(%rbp),%ecx
jge    13c0 <dt_iop_equalizer_wtf+0x2b0>
mov    %edi,%eax
sub    %r9d,%eax
add    %r14d,%eax
shl    $0x2,%eax
add    %edi,%r14d
shl    $0x2,%r14d
cltq
movslq %r14d,%rdx
movss  0x0(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x0(%r13,%rdx,4),%xmm3
movss  %xmm3,0x0(%r13,%rdx,4)
movss  0x4(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x4(%r13,%rdx,4),%xmm3
movss  %xmm3,0x4(%r13,%rdx,4)
movss  0x8(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x8(%r13,%rdx,4),%xmm3
movss  %xmm3,0x8(%r13,%rdx,4)
jmp    13c0 <dt_iop_equalizer_wtf+0x2b0>
cmpl   $0x0,-0x40(%rbp)
mov    -0x44(%rbp),%ebx
mov    -0x64(%rbp),%r11d
jle    1f23 <dt_iop_equalizer_wtf+0xe13>
mov    -0x88(%rbp),%rdx
movslq %edx,%rax
mov    %rax,-0x80(%rbp)
mov    %ebx,%esi
sub    %r9d,%esi
mov    %r9d,%edi
mov    -0x40(%rbp),%rax
imul   %eax,%edi
mov    %esi,-0x90(%rbp)
movslq %esi,%r15
mov    %edx,%esi
imul   %eax,%esi
mov    %rsi,-0xd8(%rbp)
lea    0x0(,%rsi,4),%r8d
lea    0x0(,%rdi,8),%esi
mov    %rdi,-0xb8(%rbp)
lea    0x0(,%rdi,4),%edi
mov    %edx,%ebx
sub    %r9d,%ebx
imul   %eax,%ebx
shl    $0x2,%ebx
mov    %rbx,-0xd0(%rbp)
add    %r9d,%edx
imul   %eax,%edx
mov    %rdx,-0xc8(%rbp)
lea    0x0(,%r14,4),%rax
neg    %rax
mov    %rax,-0xc0(%rbp)
xor    %eax,%eax
mov    %rax,-0x50(%rbp)
mov    -0xa0(%rbp),%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,-0xa0(%rbp)
movaps 0x697(%rip),%xmm0
movsd  0x69f(%rip),%xmm1
movsd  0x69f(%rip),%xmm2
movsd  0x69e(%rip),%xmm9
movss  0x69d(%rip),%xmm8
xor    %r12d,%r12d
mov    %rsi,-0xb0(%rbp)
mov    %r8d,-0x70(%rbp)
mov    %rdi,-0xa8(%rbp)
mov    %r15,-0x98(%rbp)
jmp    19d7 <dt_iop_equalizer_wtf+0x8c7>
nopl   0x0(%rax)
mov    -0xf0(%rbp),%rsp
add    $0x1,%r12
mov    -0x50(%rbp),%rax
add    $0x4,%eax
mov    %rax,-0x50(%rbp)
cmp    -0xf8(%rbp),%r12
mov    -0x64(%rbp),%r11d
je     1f23 <dt_iop_equalizer_wtf+0xe13>
mov    %rsp,-0xf0(%rbp)
mov    %rsp,%r10
sub    -0xa0(%rbp),%r10
mov    %r10,%rsp
cmpl   $0x0,-0x90(%rbp)
jle    1a62 <dt_iop_equalizer_wtf+0x952>
mov    -0xe8(%rbp),%rax
mov    -0xe0(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %r12d,%edx
shr    %cl,%edx
xor    %esi,%esi
nopl   (%rax)
mov    %esi,%edi
sar    %cl,%edi
lea    (%r9,%rsi,1),%ebx
imul   %r11d,%edi
add    %edx,%edi
movslq %edi,%rdi
sar    %cl,%ebx
movss  (%rax,%rdi,4),%xmm5
imul   %r11d,%ebx
add    %edx,%ebx
movslq %ebx,%rdi
subss  (%rax,%rdi,4),%xmm5
andps  %xmm0,%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm2,%xmm6
divsd  %xmm5,%xmm6
xorps  %xmm5,%xmm5
cvtsd2ss %xmm6,%xmm5
movss  %xmm5,(%r10,%rsi,4)
lea    (%rsi,%r14,1),%rdi
mov    %rdi,%rsi
cmp    %r15,%rdi
jl     1a10 <dt_iop_equalizer_wtf+0x900>
mov    %r12,-0x78(%rbp)
mov    %r9d,%r14d
cmp    -0x90(%rbp),%r9d
mov    -0x88(%rbp),%r8
mov    -0x80(%rbp),%r9
mov    -0xb0(%rbp),%r12
mov    -0x70(%rbp),%r11d
mov    -0xa8(%rbp),%rcx
jge    1bbf <dt_iop_equalizer_wtf+0xaaf>
mov    -0x38(%rbp),%rax
lea    (%r10,%rax,4),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    %eax,%r14d
xor    %edi,%edi
mov    -0x50(%rbp),%rsi
nopl   0x0(%rax)
movss  (%r10,%rdi,4),%xmm5
lea    (%r12,%rsi,1),%eax
mov    -0x60(%rbp),%rbx
movss  (%rbx,%rdi,4),%xmm7
movaps %xmm5,%xmm6
lea    (%rcx,%rsi,1),%ebx
movslq %esi,%rsi
mov    %r10,%r15
mov    %rcx,%r10
movslq %eax,%rcx
addss  %xmm7,%xmm6
movslq %ebx,%rbx
lea    0x0(,%rsi,4),%rax
movss  0x0(%r13,%rcx,4),%xmm4
mulss  %xmm7,%xmm4
movss  0x0(%r13,%rsi,4),%xmm3
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
shl    $0x2,%rcx
divss  %xmm6,%xmm3
movss  0x0(%r13,%rbx,4),%xmm4
subss  %xmm3,%xmm4
mov    %rcx,%rdx
movss  %xmm4,0x0(%r13,%rbx,4)
or     $0x4,%rdx
movss  0x0(%r13,%rdx,1),%xmm3
mov    %rax,%rdx
or     $0x4,%rdx
mulss  %xmm7,%xmm3
movss  0x0(%r13,%rdx,1),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
lea    0x0(,%rbx,4),%rbx
divss  %xmm6,%xmm4
mov    %rbx,%rdx
or     $0x4,%rdx
movss  0x0(%r13,%rdx,1),%xmm3
subss  %xmm4,%xmm3
movss  %xmm3,0x0(%r13,%rdx,1)
or     $0x8,%rcx
mulss  0x0(%r13,%rcx,1),%xmm7
mov    %r10,%rcx
mov    %r15,%r10
mov    -0x98(%rbp),%r15
or     $0x8,%rax
mulss  0x0(%r13,%rax,1),%xmm5
addss  %xmm7,%xmm5
divss  %xmm6,%xmm5
or     $0x8,%rbx
movss  0x0(%r13,%rbx,1),%xmm3
subss  %xmm5,%xmm3
add    %r11d,%esi
movss  %xmm3,0x0(%r13,%rbx,1)
add    %r9,%rdi
add    %r8d,%r14d
mov    -0x38(%rbp),%rax
add    %rdi,%rax
cmp    %r15,%rax
jl     1ab0 <dt_iop_equalizer_wtf+0x9a0>
mov    -0x44(%rbp),%ebx
mov    %r8,%r11
cmp    %ebx,%r14d
jge    1c50 <dt_iop_equalizer_wtf+0xb40>
mov    %r14d,%eax
mov    -0x58(%rbp),%r9
sub    %r9d,%eax
mov    -0x40(%rbp),%rcx
imul   %ecx,%eax
mov    -0x78(%rbp),%r12
add    %r12d,%eax
shl    $0x2,%eax
imul   %ecx,%r14d
add    %r12d,%r14d
shl    $0x2,%r14d
cltq
movslq %r14d,%rcx
movss  0x0(%r13,%rcx,4),%xmm3
movss  0x4(%r13,%rcx,4),%xmm4
subss  0x0(%r13,%rax,4),%xmm3
movss  %xmm3,0x0(%r13,%rcx,4)
subss  0x4(%r13,%rax,4),%xmm4
movss  %xmm4,0x4(%r13,%rcx,4)
movss  0x8(%r13,%rcx,4),%xmm3
subss  0x8(%r13,%rax,4),%xmm3
movss  %xmm3,0x8(%r13,%rcx,4)
mov    -0x2c(%rbp),%ecx
mov    -0x38(%rbp),%r14
mov    -0x70(%rbp),%r8d
jmp    1c63 <dt_iop_equalizer_wtf+0xb53>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x2c(%rbp),%ecx
mov    -0x58(%rbp),%r9
mov    -0x38(%rbp),%r14
mov    -0x70(%rbp),%r8d
mov    -0x78(%rbp),%r12
mov    -0xb8(%rbp),%rax
add    %r12d,%eax
shl    $0x2,%eax
lea    0x0(,%r12,4),%edx
cltq
movss  0x0(%r13,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x0(%r13,%rdx,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm9,%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,0x0(%r13,%rdx,4)
movss  0x4(%r13,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0x1(,%r12,4),%edx
movss  0x0(%r13,%rdx,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm9,%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,0x0(%r13,%rdx,4)
movss  0x8(%r13,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0x2(,%r12,4),%eax
movss  0x0(%r13,%rax,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm9,%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,0x0(%r13,%rax,4)
mov    %r11,%rax
cmp    -0x90(%rbp),%eax
jge    1ea4 <dt_iop_equalizer_wtf+0xd94>
mov    -0xd0(%rbp),%rax
lea    (%rax,%r12,4),%r9d
mov    -0xc8(%rbp),%rax
lea    (%rax,%r12,1),%r14d
shl    $0x2,%r14d
mov    -0xd8(%rbp),%rax
mov    %r12,-0x78(%rbp)
add    %r12d,%eax
shl    $0x2,%eax
mov    -0xc0(%rbp),%rcx
lea    (%r10,%rcx,1),%r12
mov    -0x80(%rbp),%rcx
mov    %rcx,%r11
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r12,%r11,4),%xmm5
movss  (%r10,%r11,4),%xmm6
movaps %xmm5,%xmm3
addss  %xmm6,%xmm3
movslq %r9d,%r9
movslq %r14d,%r14
cltq
xorps  %xmm7,%xmm7
cvtss2sd %xmm3,%xmm7
movss  0x0(%r13,%r14,4),%xmm3
mulss  %xmm6,%xmm3
movss  0x0(%r13,%r9,4),%xmm4
addsd  %xmm7,%xmm7
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
lea    0x0(,%r9,4),%rdx
divsd  %xmm7,%xmm3
movss  0x0(%r13,%rax,4),%xmm4
cvtss2sd %xmm4,%xmm4
lea    0x0(,%r14,4),%rsi
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
mov    %rdx,%rdi
movss  %xmm3,0x0(%r13,%rax,4)
or     $0x4,%rdi
mov    %rsi,%rbx
or     $0x4,%rbx
movss  0x0(%r13,%rbx,1),%xmm3
mulss  %xmm6,%xmm3
movss  0x0(%r13,%rdi,1),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
lea    0x0(,%rax,4),%rdi
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
divsd  %xmm7,%xmm3
mov    %rdi,%rbx
or     $0x4,%rbx
movss  0x0(%r13,%rbx,1),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,0x0(%r13,%rbx,1)
or     $0x8,%rsi
mulss  0x0(%r13,%rsi,1),%xmm6
or     $0x8,%rdx
mulss  0x0(%r13,%rdx,1),%xmm5
addss  %xmm6,%xmm5
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
divsd  %xmm7,%xmm3
or     $0x8,%rdi
movss  0x0(%r13,%rdi,1),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,0x0(%r13,%rdi,1)
add    %rcx,%r11
add    %r8d,%r9d
add    %r8d,%r14d
add    %r8d,%eax
cmp    %r15,%r11
jl     1d60 <dt_iop_equalizer_wtf+0xc50>
mov    -0x2c(%rbp),%ecx
mov    -0x44(%rbp),%ebx
mov    -0x58(%rbp),%r9
mov    -0x38(%rbp),%r14
mov    -0x78(%rbp),%r12
cmp    %ebx,%r11d
jge    19b0 <dt_iop_equalizer_wtf+0x8a0>
mov    %r11d,%eax
sub    %r9d,%eax
mov    -0x40(%rbp),%rdx
imul   %edx,%eax
add    %r12d,%eax
shl    $0x2,%eax
imul   %edx,%r11d
add    %r12d,%r11d
shl    $0x2,%r11d
cltq
movslq %r11d,%rdx
movss  0x0(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x0(%r13,%rdx,4),%xmm3
movss  %xmm3,0x0(%r13,%rdx,4)
movss  0x4(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x4(%r13,%rdx,4),%xmm3
movss  %xmm3,0x4(%r13,%rdx,4)
movss  0x8(%r13,%rax,4),%xmm3
mulss  %xmm8,%xmm3
addss  0x8(%r13,%rdx,4),%xmm3
movss  %xmm3,0x8(%r13,%rdx,4)
jmp    19b0 <dt_iop_equalizer_wtf+0x8a0>
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_wtf(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 i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i8*
%20 = alloca i64
%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
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
%30 = load i32, i32* %9
%31 = load i32, i32* %8
%32 = sub nsw i32 %31, 1
%33 = ashr i32 %30, %32
%34 = add nsw i32 1, %33
store i32 %34, i32* %11
%35 = load i32, i32* %10
%36 = load i32, i32* %8
%37 = sub nsw i32 %36, 1
%38 = ashr i32 %35, %37
%39 = add nsw i32 1, %38
store i32 %39, i32* %12
store i32 0, i32* %13
%40 = load float**, float*** %7
%41 = load i32, i32* %8
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float*, float** %40, i64 %42
%44 = load float*, float** %43
%45 = bitcast float* %44 to i8*
%46 = load i32, i32* %11
%47 = sext i32 %46 to i64
%48 = mul i64 4, %47
%49 = load i32, i32* %12
%50 = sext i32 %49 to i64
%51 = mul i64 %48, %50
store i32 0, i32* %14
br label %52
52: ; preds = %98, %5
%53 = load i32, i32* %14
%54 = load i32, i32* %12
%55 = sub nsw i32 %54, 1
%56 = icmp slt i32 %53, %55
br i1 %56, label %57, label %101
57: ; preds = %52
store i32 0, i32* %15
br label %58
58: ; preds = %94, %57
%59 = load i32, i32* %15
%60 = load i32, i32* %11
%61 = sub nsw i32 %60, 1
%62 = icmp slt i32 %59, %61
br i1 %62, label %63, label %97
63: ; preds = %58
%64 = load float*, float** %6
%65 = load i32, i32* %9
%66 = load i32, i32* %14
%67 = load i32, i32* %8
%68 = sub nsw i32 %67, 1
%69 = shl i32 %66, %68
%70 = mul nsw i32 %65, %69
%71 = load i32, i32* %15
%72 = load i32, i32* %8
%73 = sub nsw i32 %72, 1
%74 = shl i32 %71, %73
%75 = add nsw i32 %70, %74
%76 = mul nsw i32 4, %75
%77 = load i32, i32* %13
%78 = add nsw i32 %76, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %64, i64 %79
%81 = load float, float* %80
%82 = load float**, float*** %7
%83 = load i32, i32* %8
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float*, float** %82, i64 %84
%86 = load float*, float** %85
%87 = load i32, i32* %14
%88 = load i32, i32* %11
%89 = mul nsw i32 %87, %88
%90 = load i32, i32* %15
%91 = add nsw i32 %89, %90
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %86, i64 %92
store float %81, float* %93
br label %94
94: ; preds = %63
%95 = load i32, i32* %15
%96 = add nsw i32 %95, 1
store i32 %96, i32* %15
br label %58
97: ; preds = %58
br label %98
98: ; preds = %97
%99 = load i32, i32* %14
%100 = add nsw i32 %99, 1
store i32 %100, i32* %14
br label %52
101: ; preds = %52
%102 = load i32, i32* %8
%103 = shl i32 1, %102
store i32 %103, i32* %16
%104 = load i32, i32* %16
%105 = sdiv i32 %104, 2
store i32 %105, i32* %17
store i32 0, i32* %18
br label %106
106: ; preds = %466, %101
%107 = load i32, i32* %18
%108 = load i32, i32* %10
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %469
110: ; preds = %106
%111 = load i32, i32* %9
%112 = zext i32 %111 to i64
%113 = call i8* @llvm.stacksave()
store i8* %113, i8** %19
%114 = alloca float, i64 %112
store i64 %112, i64* %20
store i32 0, i32* %21
br label %115
115: ; preds = %171, %110
%116 = load i32, i32* %21
%117 = load i32, i32* %9
%118 = load i32, i32* %17
%119 = sub nsw i32 %117, %118
%120 = icmp slt i32 %116, %119
br i1 %120, label %121, label %175
121: ; preds = %115
%122 = load float**, float*** %7
%123 = load i32, i32* %8
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float*, float** %122, i64 %124
%126 = load float*, float** %125
%127 = load i32, i32* %11
%128 = load i32, i32* %18
%129 = load i32, i32* %8
%130 = sub nsw i32 %129, 1
%131 = ashr i32 %128, %130
%132 = mul nsw i32 %127, %131
%133 = load i32, i32* %21
%134 = load i32, i32* %8
%135 = sub nsw i32 %134, 1
%136 = ashr i32 %133, %135
%137 = add nsw i32 %132, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %126, i64 %138
%140 = load float, float* %139
%141 = load float**, float*** %7
%142 = load i32, i32* %8
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float*, float** %141, i64 %143
%145 = load float*, float** %144
%146 = load i32, i32* %11
%147 = load i32, i32* %18
%148 = load i32, i32* %8
%149 = sub nsw i32 %148, 1
%150 = ashr i32 %147, %149
%151 = mul nsw i32 %146, %150
%152 = load i32, i32* %21
%153 = load i32, i32* %17
%154 = add nsw i32 %152, %153
%155 = load i32, i32* %8
%156 = sub nsw i32 %155, 1
%157 = ashr i32 %154, %156
%158 = add nsw i32 %151, %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %145, i64 %159
%161 = load float, float* %160
%162 = fsub float %140, %161
%163 = call float @llvm.fabs.f32(float %162)
%164 = fpext float %163 to double
%165 = fadd double %164, 1.000000e-05
%166 = fdiv double 1.000000e+00, %165
%167 = fptrunc double %166 to float
%168 = load i32, i32* %21
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %114, i64 %169
store float %167, float* %170
br label %171
171: ; preds = %121
%172 = load i32, i32* %17
%173 = load i32, i32* %21
%174 = add nsw i32 %173, %172
store i32 %174, i32* %21
br label %115
175: ; preds = %115
%176 = load i32, i32* %17
store i32 %176, i32* %22
br label %177
177: ; preds = %257, %175
%178 = load i32, i32* %22
%179 = load i32, i32* %9
%180 = load i32, i32* %17
%181 = sub nsw i32 %179, %180
%182 = icmp slt i32 %178, %181
br i1 %182, label %183, label %261
183: ; preds = %177
store i32 0, i32* %13
br label %184
184: ; preds = %253, %183
%185 = load i32, i32* %13
%186 = icmp slt i32 %185, 3
br i1 %186, label %187, label %256
187: ; preds = %184
%188 = load i32, i32* %22
%189 = load i32, i32* %17
%190 = sub nsw i32 %188, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %114, i64 %191
%193 = load float, float* %192
%194 = load float*, float** %6
%195 = load i32, i32* %9
%196 = load i32, i32* %18
%197 = mul nsw i32 %195, %196
%198 = load i32, i32* %22
%199 = load i32, i32* %17
%200 = sub nsw i32 %198, %199
%201 = add nsw i32 %197, %200
%202 = mul nsw i32 4, %201
%203 = load i32, i32* %13
%204 = add nsw i32 %202, %203
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float, float* %194, i64 %205
%207 = load float, float* %206
%208 = load i32, i32* %22
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds float, float* %114, i64 %209
%211 = load float, float* %210
%212 = load float*, float** %6
%213 = load i32, i32* %9
%214 = load i32, i32* %18
%215 = mul nsw i32 %213, %214
%216 = load i32, i32* %22
%217 = load i32, i32* %17
%218 = add nsw i32 %216, %217
%219 = add nsw i32 %215, %218
%220 = mul nsw i32 4, %219
%221 = load i32, i32* %13
%222 = add nsw i32 %220, %221
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float, float* %212, i64 %223
%225 = load float, float* %224
%226 = fmul float %211, %225
%227 = call float @llvm.fmuladd.f32(float %193, float %207, float %226)
%228 = load i32, i32* %22
%229 = load i32, i32* %17
%230 = sub nsw i32 %228, %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds float, float* %114, i64 %231
%233 = load float, float* %232
%234 = load i32, i32* %22
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds float, float* %114, i64 %235
%237 = load float, float* %236
%238 = fadd float %233, %237
%239 = fdiv float %227, %238
%240 = load float*, float** %6
%241 = load i32, i32* %9
%242 = load i32, i32* %18
%243 = mul nsw i32 %241, %242
%244 = load i32, i32* %22
%245 = add nsw i32 %243, %244
%246 = mul nsw i32 4, %245
%247 = load i32, i32* %13
%248 = add nsw i32 %246, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %240, i64 %249
%251 = load float, float* %250
%252 = fsub float %251, %239
store float %252, float* %250
br label %253
253: ; preds = %187
%254 = load i32, i32* %13
%255 = add nsw i32 %254, 1
store i32 %255, i32* %13
br label %184
256: ; preds = %184
br label %257
257: ; preds = %256
%258 = load i32, i32* %16
%259 = load i32, i32* %22
%260 = add nsw i32 %259, %258
store i32 %260, i32* %22
br label %177
261: ; preds = %177
%262 = load i32, i32* %22
%263 = load i32, i32* %9
%264 = icmp slt i32 %262, %263
br i1 %264, label %265, label %301
265: ; preds = %261
store i32 0, i32* %13
br label %266
266: ; preds = %297, %265
%267 = load i32, i32* %13
%268 = icmp slt i32 %267, 3
br i1 %268, label %269, label %300
269: ; preds = %266
%270 = load float*, float** %6
%271 = load i32, i32* %9
%272 = load i32, i32* %18
%273 = mul nsw i32 %271, %272
%274 = load i32, i32* %22
%275 = load i32, i32* %17
%276 = sub nsw i32 %274, %275
%277 = add nsw i32 %273, %276
%278 = mul nsw i32 4, %277
%279 = load i32, i32* %13
%280 = add nsw i32 %278, %279
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds float, float* %270, i64 %281
%283 = load float, float* %282
%284 = load float*, float** %6
%285 = load i32, i32* %9
%286 = load i32, i32* %18
%287 = mul nsw i32 %285, %286
%288 = load i32, i32* %22
%289 = add nsw i32 %287, %288
%290 = mul nsw i32 4, %289
%291 = load i32, i32* %13
%292 = add nsw i32 %290, %291
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds float, float* %284, i64 %293
%295 = load float, float* %294
%296 = fsub float %295, %283
store float %296, float* %294
br label %297
297: ; preds = %269
%298 = load i32, i32* %13
%299 = add nsw i32 %298, 1
store i32 %299, i32* %13
br label %266
300: ; preds = %266
br label %301
301: ; preds = %300, %261
store i32 0, i32* %13
br label %302
302: ; preds = %330, %301
%303 = load i32, i32* %13
%304 = icmp slt i32 %303, 3
br i1 %304, label %305, label %333
305: ; preds = %302
%306 = load float*, float** %6
%307 = load i32, i32* %9
%308 = load i32, i32* %18
%309 = mul nsw i32 %307, %308
%310 = load i32, i32* %17
%311 = add nsw i32 %309, %310
%312 = mul nsw i32 4, %311
%313 = load i32, i32* %13
%314 = add nsw i32 %312, %313
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds float, float* %306, i64 %315
%317 = load float, float* %316
%318 = load float*, float** %6
%319 = load i32, i32* %9
%320 = load i32, i32* %18
%321 = mul nsw i32 %319, %320
%322 = add nsw i32 %321, 0
%323 = mul nsw i32 4, %322
%324 = load i32, i32* %13
%325 = add nsw i32 %323, %324
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float, float* %318, i64 %326
%328 = load float, float* %327
%329 = call float @llvm.fmuladd.f32(float %317, float 5.000000e-01, float %328)
store float %329, float* %327
br label %330
330: ; preds = %305
%331 = load i32, i32* %13
%332 = add nsw i32 %331, 1
store i32 %332, i32* %13
br label %302
333: ; preds = %302
%334 = load i32, i32* %16
store i32 %334, i32* %22
br label %335
335: ; preds = %420, %333
%336 = load i32, i32* %22
%337 = load i32, i32* %9
%338 = load i32, i32* %17
%339 = sub nsw i32 %337, %338
%340 = icmp slt i32 %336, %339
br i1 %340, label %341, label %424
341: ; preds = %335
store i32 0, i32* %13
br label %342
342: ; preds = %416, %341
%343 = load i32, i32* %13
%344 = icmp slt i32 %343, 3
br i1 %344, label %345, label %419
345: ; preds = %342
%346 = load i32, i32* %22
%347 = load i32, i32* %17
%348 = sub nsw i32 %346, %347
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds float, float* %114, i64 %349
%351 = load float, float* %350
%352 = load float*, float** %6
%353 = load i32, i32* %9
%354 = load i32, i32* %18
%355 = mul nsw i32 %353, %354
%356 = load i32, i32* %22
%357 = load i32, i32* %17
%358 = sub nsw i32 %356, %357
%359 = add nsw i32 %355, %358
%360 = mul nsw i32 4, %359
%361 = load i32, i32* %13
%362 = add nsw i32 %360, %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds float, float* %352, i64 %363
%365 = load float, float* %364
%366 = load i32, i32* %22
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds float, float* %114, i64 %367
%369 = load float, float* %368
%370 = load float*, float** %6
%371 = load i32, i32* %9
%372 = load i32, i32* %18
%373 = mul nsw i32 %371, %372
%374 = load i32, i32* %22
%375 = load i32, i32* %17
%376 = add nsw i32 %374, %375
%377 = add nsw i32 %373, %376
%378 = mul nsw i32 4, %377
%379 = load i32, i32* %13
%380 = add nsw i32 %378, %379
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds float, float* %370, i64 %381
%383 = load float, float* %382
%384 = fmul float %369, %383
%385 = call float @llvm.fmuladd.f32(float %351, float %365, float %384)
%386 = fpext float %385 to double
%387 = load i32, i32* %22
%388 = load i32, i32* %17
%389 = sub nsw i32 %387, %388
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds float, float* %114, i64 %390
%392 = load float, float* %391
%393 = load i32, i32* %22
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds float, float* %114, i64 %394
%396 = load float, float* %395
%397 = fadd float %392, %396
%398 = fpext float %397 to double
%399 = fmul double 2.000000e+00, %398
%400 = fdiv double %386, %399
%401 = load float*, float** %6
%402 = load i32, i32* %9
%403 = load i32, i32* %18
%404 = mul nsw i32 %402, %403
%405 = load i32, i32* %22
%406 = add nsw i32 %404, %405
%407 = mul nsw i32 4, %406
%408 = load i32, i32* %13
%409 = add nsw i32 %407, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %401, i64 %410
%412 = load float, float* %411
%413 = fpext float %412 to double
%414 = fadd double %413, %400
%415 = fptrunc double %414 to float
store float %415, float* %411
br label %416
416: ; preds = %345
%417 = load i32, i32* %13
%418 = add nsw i32 %417, 1
store i32 %418, i32* %13
br label %342
419: ; preds = %342
br label %420
420: ; preds = %419
%421 = load i32, i32* %16
%422 = load i32, i32* %22
%423 = add nsw i32 %422, %421
store i32 %423, i32* %22
br label %335
424: ; preds = %335
%425 = load i32, i32* %22
%426 = load i32, i32* %9
%427 = icmp slt i32 %425, %426
br i1 %427, label %428, label %464
428: ; preds = %424
store i32 0, i32* %13
br label %429
429: ; preds = %460, %428
%430 = load i32, i32* %13
%431 = icmp slt i32 %430, 3
br i1 %431, label %432, label %463
432: ; preds = %429
%433 = load float*, float** %6
%434 = load i32, i32* %9
%435 = load i32, i32* %18
%436 = mul nsw i32 %434, %435
%437 = load i32, i32* %22
%438 = load i32, i32* %17
%439 = sub nsw i32 %437, %438
%440 = add nsw i32 %436, %439
%441 = mul nsw i32 4, %440
%442 = load i32, i32* %13
%443 = add nsw i32 %441, %442
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds float, float* %433, i64 %444
%446 = load float, float* %445
%447 = load float*, float** %6
%448 = load i32, i32* %9
%449 = load i32, i32* %18
%450 = mul nsw i32 %448, %449
%451 = load i32, i32* %22
%452 = add nsw i32 %450, %451
%453 = mul nsw i32 4, %452
%454 = load i32, i32* %13
%455 = add nsw i32 %453, %454
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds float, float* %447, i64 %456
%458 = load float, float* %457
%459 = call float @llvm.fmuladd.f32(float %446, float 5.000000e-01, float %458)
store float %459, float* %457
br label %460
460: ; preds = %432
%461 = load i32, i32* %13
%462 = add nsw i32 %461, 1
store i32 %462, i32* %13
br label %429
463: ; preds = %429
br label %464
464: ; preds = %463, %424
%465 = load i8*, i8** %19
br label %466
466: ; preds = %464
%467 = load i32, i32* %18
%468 = add nsw i32 %467, 1
store i32 %468, i32* %18
br label %106
469: ; preds = %106
store i32 0, i32* %23
br label %470
470: ; preds = %833, %469
%471 = load i32, i32* %23
%472 = load i32, i32* %9
%473 = icmp slt i32 %471, %472
br i1 %473, label %474, label %836
474: ; preds = %470
%475 = load i32, i32* %10
%476 = zext i32 %475 to i64
%477 = call i8* @llvm.stacksave()
store i8* %477, i8** %24
%478 = alloca float, i64 %476
store i64 %476, i64* %25
store i32 0, i32* %26
br label %479
479: ; preds = %535, %474
%480 = load i32, i32* %26
%481 = load i32, i32* %10
%482 = load i32, i32* %17
%483 = sub nsw i32 %481, %482
%484 = icmp slt i32 %480, %483
br i1 %484, label %485, label %539
485: ; preds = %479
%486 = load float**, float*** %7
%487 = load i32, i32* %8
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds float*, float** %486, i64 %488
%490 = load float*, float** %489
%491 = load i32, i32* %11
%492 = load i32, i32* %26
%493 = load i32, i32* %8
%494 = sub nsw i32 %493, 1
%495 = ashr i32 %492, %494
%496 = mul nsw i32 %491, %495
%497 = load i32, i32* %23
%498 = load i32, i32* %8
%499 = sub nsw i32 %498, 1
%500 = ashr i32 %497, %499
%501 = add nsw i32 %496, %500
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds float, float* %490, i64 %502
%504 = load float, float* %503
%505 = load float**, float*** %7
%506 = load i32, i32* %8
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds float*, float** %505, i64 %507
%509 = load float*, float** %508
%510 = load i32, i32* %11
%511 = load i32, i32* %26
%512 = load i32, i32* %17
%513 = add nsw i32 %511, %512
%514 = load i32, i32* %8
%515 = sub nsw i32 %514, 1
%516 = ashr i32 %513, %515
%517 = mul nsw i32 %510, %516
%518 = load i32, i32* %23
%519 = load i32, i32* %8
%520 = sub nsw i32 %519, 1
%521 = ashr i32 %518, %520
%522 = add nsw i32 %517, %521
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds float, float* %509, i64 %523
%525 = load float, float* %524
%526 = fsub float %504, %525
%527 = call float @llvm.fabs.f32(float %526)
%528 = fpext float %527 to double
%529 = fadd double %528, 1.000000e-05
%530 = fdiv double 1.000000e+00, %529
%531 = fptrunc double %530 to float
%532 = load i32, i32* %26
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds float, float* %478, i64 %533
store float %531, float* %534
br label %535
535: ; preds = %485
%536 = load i32, i32* %17
%537 = load i32, i32* %26
%538 = add nsw i32 %537, %536
store i32 %538, i32* %26
br label %479
539: ; preds = %479
%540 = load i32, i32* %17
store i32 %540, i32* %27
br label %541
541: ; preds = %621, %539
%542 = load i32, i32* %27
%543 = load i32, i32* %10
%544 = load i32, i32* %17
%545 = sub nsw i32 %543, %544
%546 = icmp slt i32 %542, %545
br i1 %546, label %547, label %625
547: ; preds = %541
store i32 0, i32* %13
br label %548
548: ; preds = %617, %547
%549 = load i32, i32* %13
%550 = icmp slt i32 %549, 3
br i1 %550, label %551, label %620
551: ; preds = %548
%552 = load i32, i32* %27
%553 = load i32, i32* %17
%554 = sub nsw i32 %552, %553
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds float, float* %478, i64 %555
%557 = load float, float* %556
%558 = load float*, float** %6
%559 = load i32, i32* %9
%560 = load i32, i32* %27
%561 = load i32, i32* %17
%562 = sub nsw i32 %560, %561
%563 = mul nsw i32 %559, %562
%564 = load i32, i32* %23
%565 = add nsw i32 %563, %564
%566 = mul nsw i32 4, %565
%567 = load i32, i32* %13
%568 = add nsw i32 %566, %567
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds float, float* %558, i64 %569
%571 = load float, float* %570
%572 = load i32, i32* %27
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds float, float* %478, i64 %573
%575 = load float, float* %574
%576 = load float*, float** %6
%577 = load i32, i32* %9
%578 = load i32, i32* %27
%579 = load i32, i32* %17
%580 = add nsw i32 %578, %579
%581 = mul nsw i32 %577, %580
%582 = load i32, i32* %23
%583 = add nsw i32 %581, %582
%584 = mul nsw i32 4, %583
%585 = load i32, i32* %13
%586 = add nsw i32 %584, %585
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds float, float* %576, i64 %587
%589 = load float, float* %588
%590 = fmul float %575, %589
%591 = call float @llvm.fmuladd.f32(float %557, float %571, float %590)
%592 = load i32, i32* %27
%593 = load i32, i32* %17
%594 = sub nsw i32 %592, %593
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds float, float* %478, i64 %595
%597 = load float, float* %596
%598 = load i32, i32* %27
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds float, float* %478, i64 %599
%601 = load float, float* %600
%602 = fadd float %597, %601
%603 = fdiv float %591, %602
%604 = load float*, float** %6
%605 = load i32, i32* %9
%606 = load i32, i32* %27
%607 = mul nsw i32 %605, %606
%608 = load i32, i32* %23
%609 = add nsw i32 %607, %608
%610 = mul nsw i32 4, %609
%611 = load i32, i32* %13
%612 = add nsw i32 %610, %611
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds float, float* %604, i64 %613
%615 = load float, float* %614
%616 = fsub float %615, %603
store float %616, float* %614
br label %617
617: ; preds = %551
%618 = load i32, i32* %13
%619 = add nsw i32 %618, 1
store i32 %619, i32* %13
br label %548
620: ; preds = %548
br label %621
621: ; preds = %620
%622 = load i32, i32* %16
%623 = load i32, i32* %27
%624 = add nsw i32 %623, %622
store i32 %624, i32* %27
br label %541
625: ; preds = %541
%626 = load i32, i32* %27
%627 = load i32, i32* %10
%628 = icmp slt i32 %626, %627
br i1 %628, label %629, label %665
629: ; preds = %625
store i32 0, i32* %28
br label %630
630: ; preds = %661, %629
%631 = load i32, i32* %28
%632 = icmp slt i32 %631, 3
br i1 %632, label %633, label %664
633: ; preds = %630
%634 = load float*, float** %6
%635 = load i32, i32* %9
%636 = load i32, i32* %27
%637 = load i32, i32* %17
%638 = sub nsw i32 %636, %637
%639 = mul nsw i32 %635, %638
%640 = load i32, i32* %23
%641 = add nsw i32 %639, %640
%642 = mul nsw i32 4, %641
%643 = load i32, i32* %28
%644 = add nsw i32 %642, %643
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds float, float* %634, i64 %645
%647 = load float, float* %646
%648 = load float*, float** %6
%649 = load i32, i32* %9
%650 = load i32, i32* %27
%651 = mul nsw i32 %649, %650
%652 = load i32, i32* %23
%653 = add nsw i32 %651, %652
%654 = mul nsw i32 4, %653
%655 = load i32, i32* %28
%656 = add nsw i32 %654, %655
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds float, float* %648, i64 %657
%659 = load float, float* %658
%660 = fsub float %659, %647
store float %660, float* %658
br label %661
661: ; preds = %633
%662 = load i32, i32* %28
%663 = add nsw i32 %662, 1
store i32 %663, i32* %28
br label %630
664: ; preds = %630
br label %665
665: ; preds = %664, %625
store i32 0, i32* %13
br label %666
666: ; preds = %697, %665
%667 = load i32, i32* %13
%668 = icmp slt i32 %667, 3
br i1 %668, label %669, label %700
669: ; preds = %666
%670 = load float*, float** %6
%671 = load i32, i32* %9
%672 = load i32, i32* %17
%673 = mul nsw i32 %671, %672
%674 = load i32, i32* %23
%675 = add nsw i32 %673, %674
%676 = mul nsw i32 4, %675
%677 = load i32, i32* %13
%678 = add nsw i32 %676, %677
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds float, float* %670, i64 %679
%681 = load float, float* %680
%682 = fpext float %681 to double
%683 = load float*, float** %6
%684 = load i32, i32* %9
%685 = mul nsw i32 %684, 0
%686 = load i32, i32* %23
%687 = add nsw i32 %685, %686
%688 = mul nsw i32 4, %687
%689 = load i32, i32* %13
%690 = add nsw i32 %688, %689
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds float, float* %683, i64 %691
%693 = load float, float* %692
%694 = fpext float %693 to double
%695 = call double @llvm.fmuladd.f64(double %682, double 5.000000e-01, double %694)
%696 = fptrunc double %695 to float
store float %696, float* %692
br label %697
697: ; preds = %669
%698 = load i32, i32* %13
%699 = add nsw i32 %698, 1
store i32 %699, i32* %13
br label %666
700: ; preds = %666
%701 = load i32, i32* %16
store i32 %701, i32* %27
br label %702
702: ; preds = %787, %700
%703 = load i32, i32* %27
%704 = load i32, i32* %10
%705 = load i32, i32* %17
%706 = sub nsw i32 %704, %705
%707 = icmp slt i32 %703, %706
br i1 %707, label %708, label %791
708: ; preds = %702
store i32 0, i32* %13
br label %709
709: ; preds = %783, %708
%710 = load i32, i32* %13
%711 = icmp slt i32 %710, 3
br i1 %711, label %712, label %786
712: ; preds = %709
%713 = load i32, i32* %27
%714 = load i32, i32* %17
%715 = sub nsw i32 %713, %714
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds float, float* %478, i64 %716
%718 = load float, float* %717
%719 = load float*, float** %6
%720 = load i32, i32* %9
%721 = load i32, i32* %27
%722 = load i32, i32* %17
%723 = sub nsw i32 %721, %722
%724 = mul nsw i32 %720, %723
%725 = load i32, i32* %23
%726 = add nsw i32 %724, %725
%727 = mul nsw i32 4, %726
%728 = load i32, i32* %13
%729 = add nsw i32 %727, %728
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds float, float* %719, i64 %730
%732 = load float, float* %731
%733 = load i32, i32* %27
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds float, float* %478, i64 %734
%736 = load float, float* %735
%737 = load float*, float** %6
%738 = load i32, i32* %9
%739 = load i32, i32* %27
%740 = load i32, i32* %17
%741 = add nsw i32 %739, %740
%742 = mul nsw i32 %738, %741
%743 = load i32, i32* %23
%744 = add nsw i32 %742, %743
%745 = mul nsw i32 4, %744
%746 = load i32, i32* %13
%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 = fmul float %736, %750
%752 = call float @llvm.fmuladd.f32(float %718, float %732, float %751)
%753 = fpext float %752 to double
%754 = load i32, i32* %27
%755 = load i32, i32* %17
%756 = sub nsw i32 %754, %755
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds float, float* %478, i64 %757
%759 = load float, float* %758
%760 = load i32, i32* %27
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds float, float* %478, i64 %761
%763 = load float, float* %762
%764 = fadd float %759, %763
%765 = fpext float %764 to double
%766 = fmul double 2.000000e+00, %765
%767 = fdiv double %753, %766
%768 = load float*, float** %6
%769 = load i32, i32* %9
%770 = load i32, i32* %27
%771 = mul nsw i32 %769, %770
%772 = load i32, i32* %23
%773 = add nsw i32 %771, %772
%774 = mul nsw i32 4, %773
%775 = load i32, i32* %13
%776 = add nsw i32 %774, %775
%777 = sext i32 %776 to i64
%778 = getelementptr inbounds float, float* %768, i64 %777
%779 = load float, float* %778
%780 = fpext float %779 to double
%781 = fadd double %780, %767
%782 = fptrunc double %781 to float
store float %782, float* %778
br label %783
783: ; preds = %712
%784 = load i32, i32* %13
%785 = add nsw i32 %784, 1
store i32 %785, i32* %13
br label %709
786: ; preds = %709
br label %787
787: ; preds = %786
%788 = load i32, i32* %16
%789 = load i32, i32* %27
%790 = add nsw i32 %789, %788
store i32 %790, i32* %27
br label %702
791: ; preds = %702
%792 = load i32, i32* %27
%793 = load i32, i32* %10
%794 = icmp slt i32 %792, %793
br i1 %794, label %795, label %831
795: ; preds = %791
store i32 0, i32* %29
br label %796
796: ; preds = %827, %795
%797 = load i32, i32* %29
%798 = icmp slt i32 %797, 3
br i1 %798, label %799, label %830
799: ; preds = %796
%800 = load float*, float** %6
%801 = load i32, i32* %9
%802 = load i32, i32* %27
%803 = load i32, i32* %17
%804 = sub nsw i32 %802, %803
%805 = mul nsw i32 %801, %804
%806 = load i32, i32* %23
%807 = add nsw i32 %805, %806
%808 = mul nsw i32 4, %807
%809 = load i32, i32* %29
%810 = add nsw i32 %808, %809
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds float, float* %800, i64 %811
%813 = load float, float* %812
%814 = load float*, float** %6
%815 = load i32, i32* %9
%816 = load i32, i32* %27
%817 = mul nsw i32 %815, %816
%818 = load i32, i32* %23
%819 = add nsw i32 %817, %818
%820 = mul nsw i32 4, %819
%821 = load i32, i32* %29
%822 = add nsw i32 %820, %821
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds float, float* %814, i64 %823
%825 = load float, float* %824
%826 = call float @llvm.fmuladd.f32(float %813, float 5.000000e-01, float %825)
store float %826, float* %824
br label %827
827: ; preds = %799
%828 = load i32, i32* %29
%829 = add nsw i32 %828, 1
store i32 %829, i32* %29
br label %796
830: ; preds = %796
br label %831
831: ; preds = %830, %791
%832 = load i8*, i8** %24
br label %833
833: ; preds = %831
%834 = load i32, i32* %23
%835 = add nsw i32 %834, 1
store i32 %835, i32* %23
br label %470
836: ; preds = %470
ret void
}

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