float silk_burg_modified_FLP(float A[], const float x[], const float minInvGain,
                             const int subfr_length, const int nb_subfr,
                             const int D) {
  int k, n, s, reached_max_gain;
  double C0, invGain, num, nrg_f, nrg_b, rc, Atmp, tmp1, tmp2;
  const float *x_ptr;
  double C_first_row[24], C_last_row[24];
  double CAf[24 + 1], CAb[24 + 1];
  double Af[24];
  ;
  C0 = silk_energy_FLP(x, nb_subfr * subfr_length);
  memset((C_first_row), (0), (24 * sizeof(double)));
  for (s = 0; s < nb_subfr; s++) {
    x_ptr = x + s * subfr_length;
    for (n = 1; n < D + 1; n++) {
      C_first_row[n - 1] +=
          silk_inner_product_FLP(x_ptr, x_ptr + n, subfr_length - n);
    }
  }
  memcpy((C_last_row), (C_first_row), (24 * sizeof(double)));
  CAb[0] = CAf[0] = C0 + 1e-5f * C0 + 1e-9f;
  invGain = 1.0f;
  reached_max_gain = 0;
  for (n = 0; n < D; n++) {
    for (s = 0; s < nb_subfr; s++) {
      x_ptr = x + s * subfr_length;
      tmp1 = x_ptr[n];
      tmp2 = x_ptr[subfr_length - n - 1];
      for (k = 0; k < n; k++) {
        C_first_row[k] -= x_ptr[n] * x_ptr[n - k - 1];
        C_last_row[k] -=
            x_ptr[subfr_length - n - 1] * x_ptr[subfr_length - n + k];
        Atmp = Af[k];
        tmp1 += x_ptr[n - k - 1] * Atmp;
        tmp2 += x_ptr[subfr_length - n + k] * Atmp;
      }
      for (k = 0; k <= n; k++) {
        CAf[k] -= tmp1 * x_ptr[n - k];
        CAb[k] -= tmp2 * x_ptr[subfr_length - n + k - 1];
      }
    }
    tmp1 = C_first_row[n];
    tmp2 = C_last_row[n];
    for (k = 0; k < n; k++) {
      Atmp = Af[k];
      tmp1 += C_last_row[n - k - 1] * Atmp;
      tmp2 += C_first_row[n - k - 1] * Atmp;
    }
    CAf[n + 1] = tmp1;
    CAb[n + 1] = tmp2;
    num = CAb[n + 1];
    nrg_b = CAb[0];
    nrg_f = CAf[0];
    for (k = 0; k < n; k++) {
      Atmp = Af[k];
      num += CAb[n - k] * Atmp;
      nrg_b += CAb[k + 1] * Atmp;
      nrg_f += CAf[k + 1] * Atmp;
    };
    ;
    rc = -2.0 * num / (nrg_f + nrg_b);
    ;
    tmp1 = invGain * (1.0 - rc * rc);
    if (tmp1 <= minInvGain) {
      rc = sqrt(1.0 - minInvGain / invGain);
      if (num > 0) {
        rc = -rc;
      }
      invGain = minInvGain;
      reached_max_gain = 1;
    } else {
      invGain = tmp1;
    }
    for (k = 0; k < (n + 1) >> 1; k++) {
      tmp1 = Af[k];
      tmp2 = Af[n - k - 1];
      Af[k] = tmp1 + rc * tmp2;
      Af[n - k - 1] = tmp2 + rc * tmp1;
    }
    Af[n] = rc;
    if (reached_max_gain) {
      for (k = n + 1; k < D; k++) {
        Af[k] = 0.0;
      }
      break;
    }
    for (k = 0; k <= n + 1; k++) {
      tmp1 = CAf[k];
      CAf[k] += rc * CAb[n - k + 1];
      CAb[n - k + 1] += rc * tmp1;
    }
  }
  if (reached_max_gain) {
    for (k = 0; k < D; k++) {
      A[k] = (float)(-Af[k]);
    }
    for (s = 0; s < nb_subfr; s++) {
      C0 -= silk_energy_FLP(x + s * subfr_length, D);
    }
    nrg_f = C0 * invGain;
  } else {
    nrg_f = CAf[0];
    tmp1 = 1.0;
    for (k = 0; k < D; k++) {
      Atmp = Af[k];
      nrg_f += CAf[k + 1] * Atmp;
      tmp1 += Atmp * Atmp;
      A[k] = (float)(-Atmp);
    }
    nrg_f -= 1e-5f * C0 * tmp1;
  }
  return (float)nrg_f;
}


x86 assembly (clang, -O0):
<silk_burg_modified_FLP>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
imul   -0x18(%rbp),%esi
mov    $0x0,%al
call   1070 <silk_energy_FLP@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    -0x140(%rbp),%rdi
xor    %esi,%esi
mov    $0xc0,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1243 <silk_burg_modified_FLP+0xf3>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1230 <silk_burg_modified_FLP+0xe0>
mov    -0x80(%rbp),%rdi
mov    -0x80(%rbp),%rsi
movslq -0x28(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x18(%rbp),%edx
sub    -0x28(%rbp),%edx
mov    $0x0,%al
call   1030 <silk_inner_product_FLP@plt>
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
cltq
addsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x140(%rbp,%rax,8)
ff ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11d3 <silk_burg_modified_FLP+0x83>
jmp    1235 <silk_burg_modified_FLP+0xe5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a7 <silk_burg_modified_FLP+0x57>
lea    -0x200(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0xc0,%edx
call   1050 <memcpy@plt>
movsd  -0x38(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
movsd  0xda3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xd8b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  %xmm0,-0x3a0(%rbp)
ff
movsd  0xd67(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    195b <silk_burg_modified_FLP+0x80b>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    150d <silk_burg_modified_FLP+0x3bd>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1433 <silk_burg_modified_FLP+0x2e3>
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movslq -0x24(%rbp),%rax
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp,%rax,8)
ff ff
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movslq -0x24(%rbp),%rax
movsd  -0x200(%rbp,%rax,8),%xmm0
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp,%rax,8)
ff ff
movslq -0x24(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    131f <silk_burg_modified_FLP+0x1cf>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     14fa <silk_burg_modified_FLP+0x3aa>
movsd  -0x70(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movslq -0x24(%rbp),%rax
movsd  -0x2d0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
movsd  -0x78(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movslq -0x24(%rbp),%rax
movsd  -0x3a0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3a0(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    143a <silk_burg_modified_FLP+0x2ea>
jmp    14ff <silk_burg_modified_FLP+0x3af>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12bf <silk_burg_modified_FLP+0x16f>
movslq -0x28(%rbp),%rax
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x70(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0x200(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15ba <silk_burg_modified_FLP+0x46a>
movslq -0x24(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x200(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1538 <silk_burg_modified_FLP+0x3e8>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x3a0(%rbp,%rax,8)
ff ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x3a0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x3a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x2d0(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    16c1 <silk_burg_modified_FLP+0x571>
movslq -0x24(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
cltq
movsd  -0x3a0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x3a0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x2d0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    161d <silk_burg_modified_FLP+0x4cd>
movsd  0x94f(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
movsd  0x8ed(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     17a9 <silk_burg_modified_FLP+0x659>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
divsd  -0x40(%rbp),%xmm1
movsd  0x8b2(%rip),%xmm0
subsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    178f <silk_burg_modified_FLP+0x63f>
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x30(%rbp)
jmp    17b3 <silk_burg_modified_FLP+0x663>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
cmp    %ecx,%eax
jge    1856 <silk_burg_modified_FLP+0x706>
movslq -0x24(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  %xmm0,-0x460(%rbp,%rax,8)
ff ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  %xmm0,-0x460(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17ba <silk_burg_modified_FLP+0x66a>
movsd  -0x60(%rbp),%xmm0
movslq -0x28(%rbp),%rax
movsd  %xmm0,-0x460(%rbp,%rax,8)
ff ff
cmpl   $0x0,-0x30(%rbp)
je     18aa <silk_burg_modified_FLP+0x75a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    18a5 <silk_burg_modified_FLP+0x755>
movslq -0x24(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x460(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    187b <silk_burg_modified_FLP+0x72b>
jmp    195b <silk_burg_modified_FLP+0x80b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1948 <silk_burg_modified_FLP+0x7f8>
movslq -0x24(%rbp),%rax
movsd  -0x2d0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x3a0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x24(%rbp),%rax
movsd  -0x2d0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x3a0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3a0(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    18b1 <silk_burg_modified_FLP+0x761>
jmp    194d <silk_burg_modified_FLP+0x7fd>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12ac <silk_burg_modified_FLP+0x15c>
cmpl   $0x0,-0x30(%rbp)
je     1a20 <silk_burg_modified_FLP+0x8d0>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    19bb <silk_burg_modified_FLP+0x86b>
movslq -0x24(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    196c <silk_burg_modified_FLP+0x81c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a0c <silk_burg_modified_FLP+0x8bc>
mov    -0x10(%rbp),%rdi
mov    -0x2c(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%esi
mov    $0x0,%al
call   1070 <silk_energy_FLP@plt>
cvtsi2sd %eax,%xmm1
movsd  -0x38(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19c2 <silk_burg_modified_FLP+0x872>
movsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1b19 <silk_burg_modified_FLP+0x9c9>
movsd  -0x2d0(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  0x5cb(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1ade <silk_burg_modified_FLP+0x98e>
movslq -0x24(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x2d0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1a41 <silk_burg_modified_FLP+0x8f1>
movsd  0x52a(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<silk_burg_modified_FLP>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x488,%rsp
mov    %r8d,%ebp
mov    %ecx,%r14d
mov    %edx,%ebx
movss  %xmm0,0x10(%rsp)
mov    %rsi,%rax
mov    %rdi,0x60(%rsp)
mov    %ecx,%esi
imul   %edx,%esi
mov    %rax,0x20(%rsp)
mov    %rax,%rdi
xor    %eax,%eax
call   1070 <silk_energy_FLP@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x230(%rsp)
movapd %xmm0,0x240(%rsp)
movapd %xmm0,0x250(%rsp)
movapd %xmm0,0x260(%rsp)
movapd %xmm0,0x270(%rsp)
movapd %xmm0,0x280(%rsp)
movapd %xmm0,0x290(%rsp)
movapd %xmm0,0x2a0(%rsp)
movapd %xmm0,0x2b0(%rsp)
movapd %xmm0,0x2c0(%rsp)
movapd %xmm0,0x2d0(%rsp)
movapd %xmm0,0x2e0(%rsp)
movslq %ebx,%rax
mov    %rax,0x28(%rsp)
mov    %r14d,%ebx
mov    %r14d,0x34(%rsp)
test   %r14d,%r14d
mov    %rbp,0x48(%rsp)
mov    %rbx,0x58(%rsp)
jle    12d9 <silk_burg_modified_FLP+0x189>
lea    0x1(%rbp),%eax
mov    0x28(%rsp),%rdx
lea    -0x1(%rdx),%ecx
mov    %ecx,0x38(%rsp)
mov    0x20(%rsp),%rcx
lea    0x4(%rcx),%r15
lea    0x0(,%rdx,4),%rcx
mov    %rcx,0x18(%rsp)
lea    -0x4(,%rax,4),%r13
ff
xor    %r14d,%r14d
jmp    1278 <silk_burg_modified_FLP+0x128>
nopl   (%rax)
add    $0x1,%r14
add    0x18(%rsp),%r15
mov    0x58(%rsp),%rbx
cmp    %rbx,%r14
mov    0x48(%rsp),%rbp
je     12d9 <silk_burg_modified_FLP+0x189>
test   %ebp,%ebp
jle    1260 <silk_burg_modified_FLP+0x110>
mov    %r14,%rax
imul   0x28(%rsp),%rax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,4),%rbp
xor    %r12d,%r12d
mov    0x38(%rsp),%ebx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%r12,1),%rsi
mov    %rbp,%rdi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <silk_inner_product_FLP@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x230(%rsp,%r12,2),%xmm0
movsd  %xmm0,0x230(%rsp,%r12,2)
add    $0xffffffff,%ebx
add    $0x4,%r12
cmp    %r12,%r13
jne    12a0 <silk_burg_modified_FLP+0x150>
jmp    1260 <silk_burg_modified_FLP+0x110>
lea    0x3c0(%rsp),%rdi
lea    0x230(%rsp),%rsi
mov    $0xc0,%edx
call   1050 <memcpy@plt>
movsd  0x1d04(%rip),%xmm14
movsd  0x8(%rsp),%xmm1
mulsd  %xmm1,%xmm14
addsd  %xmm1,%xmm14
addsd  0x1cf3(%rip),%xmm14
movsd  %xmm14,0xa0(%rsp)
movsd  %xmm14,0x2f0(%rsp)
test   %ebp,%ebp
jle    1dde <silk_burg_modified_FLP+0xc8e>
mov    $0xffffffff,%r15d
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm10
mov    %ebp,%eax
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%rbx
lea    -0x4(%rbx),%rax
mov    %rax,0x80(%rsp)
mov    0x28(%rsp),%rcx
lea    0x0(,%rcx,4),%rax
mov    %rax,0x38(%rsp)
lea    (%rcx,%r15,1),%rax
mov    %rax,0x78(%rsp)
movsd  0x1c92(%rip),%xmm9
mov    $0x1,%dl
mov    $0x2,%ebp
mov    $0x1,%r12d
mov    $0xffffffffffffffff,%rax
xor    %r8d,%r8d
movapd 0x1c93(%rip),%xmm7
movsd  0x1c72(%rip),%xmm11
xorpd  %xmm12,%xmm12
movapd 0x1c7c(%rip),%xmm13
movapd %xmm9,%xmm8
movabs $0x200000000,%r13
xor    %r9d,%r9d
movsd  %xmm10,0x70(%rsp)
jmp    13f0 <silk_burg_modified_FLP+0x2a0>
nop
mov    0x40(%rsp),%rcx
cmp    %rcx,%r9
setl   %dl
add    $0x1,%r12
add    $0x1,%rbp
add    $0x1,%rax
cmp    %rcx,%r9
je     1da5 <silk_burg_modified_FLP+0xc55>
mov    %dl,0x7(%rsp)
mov    %rax,0x88(%rsp)
mov    %rbp,0x90(%rsp)
mov    %r9,%r14
mov    %r8,0x68(%rsp)
cmpl   $0x0,0x34(%rsp)
jle    16d0 <silk_burg_modified_FLP+0x580>
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
mov    0x28(%rsp),%rsi
mov    %rsi,%rcx
sub    %r14,%rcx
mov    %r14d,%edx
not    %edx
add    %esi,%edx
mov    0x68(%rsp),%rdi
lea    (%rdi,%rdx,1),%esi
cmp    %edx,%esi
setl   %r8b
mov    %rdi,%rsi
shr    $0x20,%rsi
setne  %dl
or     %r8b,%dl
mov    %dl,0x18(%rsp)
mov    %r12,%rsi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rsi
mov    %rsi,0x50(%rsp)
mov    0x80(%rsp),%rdx
lea    (%rdx,%r14,4),%r8
mov    0x78(%rsp),%rdx
mov    %edx,%esi
sub    %r14d,%esi
shl    $0x20,%rsi
mov    %rsi,0x98(%rsp)
sub    %r14,%rdx
mov    %rdx,0x10(%rsp)
lea    (%rbx,%r14,4),%r10
xor    %r9d,%r9d
jmp    14bf <silk_burg_modified_FLP+0x36f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    0x38(%rsp),%rdx
add    %rdx,%r8
add    %rdx,%r10
cmp    0x58(%rsp),%r9
mov    0x20(%rsp),%rbx
je     16d0 <silk_burg_modified_FLP+0x580>
mov    %r9,%rsi
imul   0x28(%rsp),%rsi
lea    (%rbx,%rsi,4),%rsi
movss  (%rsi,%r14,4),%xmm1
movss  -0x4(%rsi,%rcx,4),%xmm2
movaps %xmm1,%xmm0
unpcklps %xmm2,%xmm0
cvtps2pd %xmm0,%xmm0
test   %r14,%r14
je     1598 <silk_burg_modified_FLP+0x448>
mov    %r8,%rdi
xor    %ebx,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm3
movss  (%rdi),%xmm0
movaps %xmm1,%xmm4
mulss  %xmm0,%xmm4
cvtss2sd %xmm4,%xmm4
movsd  0x230(%rsp,%rbp,8),%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,0x230(%rsp,%rbp,8)
mov    %rbx,%rdx
sar    $0x20,%rdx
add    %rcx,%rdx
movss  (%rsi,%rdx,4),%xmm4
movaps %xmm2,%xmm5
mulss  %xmm4,%xmm5
cvtss2sd %xmm5,%xmm5
movsd  0x3c0(%rsp,%rbp,8),%xmm6
subsd  %xmm5,%xmm6
movsd  %xmm6,0x3c0(%rsp,%rbp,8)
unpcklps %xmm4,%xmm0
cvtps2pd %xmm0,%xmm0
movsd  0x170(%rsp,%rbp,8),%xmm4
unpcklpd %xmm4,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm3,%xmm0
add    $0x1,%rbp
add    %r15,%rbx
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rdi
cmp    %rbp,%r14
jne    1500 <silk_burg_modified_FLP+0x3b0>
addpd  %xmm3,%xmm4
movapd %xmm4,%xmm0
cmp    $0x2,%r12
setb   %bl
movapd %xmm0,%xmm1
xorpd  %xmm7,%xmm1
unpckhpd %xmm0,%xmm0
xorpd  %xmm7,%xmm0
or     0x18(%rsp),%bl
je     15c0 <silk_burg_modified_FLP+0x470>
xor    %r11d,%r11d
jmp    1644 <silk_burg_modified_FLP+0x4f4>
nopl   (%rax)
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mov    0x98(%rsp),%rdx
mov    %r8,%rbp
xor    %ebx,%ebx
nopl   (%rax)
movsd  0x0(%rbp),%xmm4
shufps $0xe1,%xmm4,%xmm4
cvtps2pd %xmm4,%xmm4
mulpd  %xmm2,%xmm4
addpd  0xa0(%rsp,%rbx,8),%xmm4
movapd %xmm4,0xa0(%rsp,%rbx,8)
mov    %rdx,%rdi
sar    $0x1e,%rdi
cvtps2pd (%rsi,%rdi,1),%xmm4
mulpd  %xmm3,%xmm4
addpd  0x2f0(%rsp,%rbx,8),%xmm4
movapd %xmm4,0x2f0(%rsp,%rbx,8)
add    $0x2,%rbx
add    $0xfffffffffffffff8,%rbp
add    %r13,%rdx
cmp    %rbx,%rax
jne    15e0 <silk_burg_modified_FLP+0x490>
mov    0x50(%rsp),%rdx
mov    %rdx,%r11
cmp    %rdx,%r12
je     14a0 <silk_burg_modified_FLP+0x350>
mov    0x10(%rsp),%rdx
lea    (%rdx,%r11,1),%ebx
shl    $0x20,%rbx
lea    0x0(,%r11,4),%rdx
mov    %r10,%rdi
sub    %rdx,%rdi
nop
movss  (%rdi),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  0xa0(%rsp,%r11,8),%xmm2
movsd  %xmm2,0xa0(%rsp,%r11,8)
lea    (%r15,%rbx,1),%rdx
add    $0x1,%rdx
sar    $0x1e,%rbx
movss  (%rsi,%rbx,1),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  0x2f0(%rsp,%r11,8),%xmm2
movsd  %xmm2,0x2f0(%rsp,%r11,8)
add    $0x1,%r11
add    $0xfffffffffffffffc,%rdi
mov    %rdx,%rbx
cmp    %r11,%r12
jne    1660 <silk_burg_modified_FLP+0x510>
jmp    14a0 <silk_burg_modified_FLP+0x350>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x230(%rsp,%r14,8),%xmm0
movsd  0x3c0(%rsp,%r14,8),%xmm6
test   %r14,%r14
je     1890 <silk_burg_modified_FLP+0x740>
mov    %r14,%rax
add    $0xffffffffffffffff,%rax
je     18d0 <silk_burg_modified_FLP+0x780>
lea    0x228(%rsp),%rcx
lea    (%rcx,%r14,8),%rdx
lea    0x3b8(%rsp),%rcx
lea    (%rcx,%r14,8),%rsi
mov    %r14,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xor    %ecx,%ecx
lea    0x178(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp),%xmm1
movsd  (%rsi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  (%rdx,%rcx,8),%xmm1
addsd  %xmm6,%xmm1
movsd  0x0(%rbp),%xmm3
addsd  %xmm0,%xmm2
movsd  -0x8(%rsi,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
mulsd  -0x8(%rdx,%rcx,8),%xmm3
movapd %xmm3,%xmm6
addsd  %xmm1,%xmm6
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rcx
cmp    %rcx,%rdi
jne    1730 <silk_burg_modified_FLP+0x5e0>
neg    %rcx
test   $0x1,%r14b
je     17af <silk_burg_modified_FLP+0x65f>
movsd  0x170(%rsp,%rcx,8),%xmm1
not    %rcx
add    %r14,%rcx
movsd  0x3c0(%rsp,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
mulsd  0x230(%rsp,%rcx,8),%xmm1
addsd  %xmm1,%xmm6
movsd  %xmm0,0xa8(%rsp,%r14,8)
movsd  %xmm6,0x2f8(%rsp,%r14,8)
movsd  0x2f0(%rsp),%xmm0
movsd  0xa0(%rsp),%xmm14
test   %r14,%r14
je     18f0 <silk_burg_modified_FLP+0x7a0>
test   %rax,%rax
je     18fd <silk_burg_modified_FLP+0x7ad>
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rsp,%r14,8),%rcx
add    $0x2f0,%rcx
xor    %esi,%esi
movapd %xmm14,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x170(%rsp,%rsi,8),%xmm3
movsd  0x178(%rsp,%rsi,8),%xmm2
movsd  (%rcx),%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm6,%xmm4
movsd  0x2f8(%rsp,%rsi,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm0,%xmm5
mulsd  0xa8(%rsp,%rsi,8),%xmm3
addsd  %xmm1,%xmm3
movsd  -0x8(%rcx),%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm4,%xmm6
lea    0x2(%rsi),%rdx
movsd  0x300(%rsp,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
mulsd  0xb0(%rsp,%rsi,8),%xmm2
addsd  %xmm5,%xmm0
addsd  %xmm3,%xmm2
add    $0xfffffffffffffff0,%rcx
mov    %rdx,%rsi
movapd %xmm2,%xmm1
cmp    %rdx,%rax
jne    1810 <silk_burg_modified_FLP+0x6c0>
jmp    1904 <silk_burg_modified_FLP+0x7b4>
nopl   (%rax)
movsd  %xmm0,0xa8(%rsp,%r14,8)
movsd  %xmm6,0x2f8(%rsp,%r14,8)
movsd  0x2f0(%rsp),%xmm0
mov    $0x1,%r9d
movsd  0xa0(%rsp),%xmm14
movapd %xmm14,%xmm2
jmp    194c <silk_burg_modified_FLP+0x7fc>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   $0x1,%r14b
jne    1782 <silk_burg_modified_FLP+0x632>
jmp    17af <silk_burg_modified_FLP+0x65f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x1,%r9d
movapd %xmm14,%xmm2
jmp    194c <silk_burg_modified_FLP+0x7fc>
xor    %edx,%edx
movapd %xmm14,%xmm2
lea    0x1(%r14),%r9
test   $0x1,%r14b
je     194c <silk_burg_modified_FLP+0x7fc>
movsd  0x170(%rsp,%rdx,8),%xmm1
mov    %r14,%rax
sub    %rdx,%rax
movsd  0x2f0(%rsp,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm3,%xmm6
movsd  0x2f8(%rsp,%rdx,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
mulsd  0xa8(%rsp,%rdx,8),%xmm1
addsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm6,%xmm1
mulsd  %xmm11,%xmm1
divsd  %xmm2,%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm9,%xmm4
subsd  %xmm0,%xmm4
mulsd  %xmm8,%xmm4
ucomisd %xmm4,%xmm10
movapd %xmm4,%xmm0
jb     1a32 <silk_burg_modified_FLP+0x8e2>
movapd %xmm10,%xmm1
divsd  %xmm8,%xmm1
movapd %xmm9,%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm12,%xmm0
jb     19b0 <silk_burg_modified_FLP+0x860>
sqrtsd %xmm0,%xmm0
jmp    1a10 <silk_burg_modified_FLP+0x8c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm14,0x18(%rsp)
mov    %r9,%rbp
movsd  %xmm6,0x10(%rsp)
movsd  %xmm4,0x50(%rsp)
call   1060 <sqrt@plt>
movsd  0x50(%rsp),%xmm4
movsd  0x10(%rsp),%xmm6
mov    %rbp,%r9
movsd  0x18(%rsp),%xmm14
movapd 0x1646(%rip),%xmm13
xorpd  %xmm12,%xmm12
movsd  0x1620(%rip),%xmm11
movapd 0x1630(%rip),%xmm7
movsd  0x1607(%rip),%xmm9
movsd  0x70(%rsp),%xmm10
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
xorpd  %xmm1,%xmm1
cmpltsd %xmm6,%xmm1
andpd  %xmm1,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movaps %xmm10,%xmm0
movapd %xmm0,%xmm8
test   %r14,%r14
je     1b35 <silk_burg_modified_FLP+0x9e5>
mov    %r9d,%ecx
shr    %ecx
cmp    $0x2,%rcx
mov    $0x1,%eax
cmovae %rcx,%rax
cmp    $0x2,%ecx
jae    1a70 <silk_burg_modified_FLP+0x920>
xor    %ecx,%ecx
test   $0x1,%al
jne    1af4 <silk_burg_modified_FLP+0x9a4>
jmp    1b35 <silk_burg_modified_FLP+0x9e5>
cs nopw 0x0(%rax,%rax,1)
lea    0x178(%rsp),%rdi
lea    (%rdi,%r14,8),%rdx
add    $0xfffffffffffffff0,%rdx
mov    %eax,%esi
and    $0xfffffffe,%esi
neg    %rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdi),%xmm0
movsd  (%rdx,%rcx,8),%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,-0x8(%rdi)
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%rdi),%xmm0
movsd  -0x8(%rdx,%rcx,8),%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%rdi)
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x8(%rdx,%rcx,8)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rcx
cmp    %rcx,%rsi
jne    1a90 <silk_burg_modified_FLP+0x940>
neg    %rcx
test   $0x1,%al
je     1b35 <silk_burg_modified_FLP+0x9e5>
movsd  0x170(%rsp,%rcx,8),%xmm0
mov    %rcx,%rax
not    %rax
add    %r14,%rax
movsd  0x170(%rsp,%rax,8),%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,0x170(%rsp,%rcx,8)
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x170(%rsp,%rax,8)
ucomisd %xmm4,%xmm10
movsd  %xmm1,0x170(%rsp,%r14,8)
jae    1d30 <silk_burg_modified_FLP+0xbe0>
mov    0x68(%rsp),%rdx
lea    0x1(%rdx),%r8
movsd  0x2f0(%rsp,%r9,8),%xmm0
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm14,%xmm2
movsd  %xmm2,0xa0(%rsp)
mulsd  %xmm1,%xmm14
addsd  %xmm0,%xmm14
movsd  %xmm14,0x2f0(%rsp,%r9,8)
mov    $0x1,%ecx
cmp    $0x2,%r8
mov    0x90(%rsp),%rbp
mov    0x88(%rsp),%rax
jb     1cd8 <silk_burg_modified_FLP+0xb88>
add    $0xffffffffffffffff,%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmp    $0x2,%rdx
jae    1bd0 <silk_burg_modified_FLP+0xa80>
xor    %edx,%edx
jmp    1c70 <silk_burg_modified_FLP+0xb20>
nopl   0x0(%rax)
mov    %rax,%rsi
shr    %rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x2e0(%rsp),%rdx
lea    (%rdx,%r9,8),%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movupd 0xa8(%rsp,%rdx,8),%xmm2
movupd (%rdi),%xmm3
shufpd $0x1,%xmm3,%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,0xa8(%rsp,%rdx,8)
mulpd  %xmm0,%xmm2
addpd  %xmm3,%xmm2
shufpd $0x1,%xmm2,%xmm2
movupd %xmm2,(%rdi)
movupd 0xb8(%rsp,%rdx,8),%xmm2
movupd -0x10(%rdi),%xmm3
shufpd $0x1,%xmm3,%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,0xb8(%rsp,%rdx,8)
mulpd  %xmm0,%xmm2
addpd  %xmm3,%xmm2
shufpd $0x1,%xmm2,%xmm2
movupd %xmm2,-0x10(%rdi)
add    $0x4,%rdx
add    $0xffffffffffffffe0,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1bf0 <silk_burg_modified_FLP+0xaa0>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
test   $0x1,%cl
je     1cc8 <silk_burg_modified_FLP+0xb78>
or     $0x1,%rdx
movupd 0xa0(%rsp,%rdx,8),%xmm2
mov    %r9,%rcx
sub    %rdx,%rcx
movupd 0x2e8(%rsp,%rcx,8),%xmm3
shufpd $0x1,%xmm3,%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,0xa0(%rsp,%rdx,8)
mulpd  %xmm2,%xmm0
addpd  %xmm3,%xmm0
shufpd $0x1,%xmm0,%xmm0
movupd %xmm0,0x2e8(%rsp,%rcx,8)
cmp    %rsi,%r8
je     13d0 <silk_burg_modified_FLP+0x280>
mov    %r8,%rcx
or     $0x1,%rcx
mov    %r9,%rdx
sub    %rcx,%rdx
lea    (%rsp,%rdx,8),%rdx
add    $0x2f0,%rdx
nopl   0x0(%rax)
movsd  0xa0(%rsp,%rcx,8),%xmm0
movsd  (%rdx),%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,0xa0(%rsp,%rcx,8)
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx)
add    $0x1,%rcx
add    $0xfffffffffffffff8,%rdx
cmp    %rcx,%rbp
jne    1cf0 <silk_burg_modified_FLP+0xba0>
jmp    13d0 <silk_burg_modified_FLP+0x280>
mov    0x48(%rsp),%r14
cmp    %r14d,%r9d
mov    0x60(%rsp),%rbx
movsd  %xmm8,0x10(%rsp)
jge    1d74 <silk_burg_modified_FLP+0xc24>
lea    (%rsp,%r9,8),%rdi
add    $0x170,%rdi
not    %r9d
add    %r14d,%r9d
lea    0x8(,%r9,8),%rdx
xor    %esi,%esi
movsd  %xmm14,0x18(%rsp)
call   1040 <memset@plt>
movsd  0x18(%rsp),%xmm14
testb  $0x1,0x7(%rsp)
mov    0x58(%rsp),%rbp
mov    0x40(%rsp),%rsi
mov    0x38(%rsp),%r15
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
je     1dbe <silk_burg_modified_FLP+0xc6e>
cmp    $0x4,%r14d
jae    1ef5 <silk_burg_modified_FLP+0xda5>
xor    %eax,%eax
jmp    1fa6 <silk_burg_modified_FLP+0xe56>
movsd  0xa0(%rsp),%xmm14
mov    0x60(%rsp),%rbx
mov    0x48(%rsp),%r14
mov    0x40(%rsp),%rsi
test   %r14d,%r14d
movsd  0x8(%rsp),%xmm1
jle    1dde <silk_burg_modified_FLP+0xc8e>
cmp    $0x1,%r14d
jne    1deb <silk_burg_modified_FLP+0xc9b>
movsd  0x1239(%rip),%xmm0
xor    %eax,%eax
jmp    1e83 <silk_burg_modified_FLP+0xd33>
movsd  0x122a(%rip),%xmm0
jmp    1ecb <silk_burg_modified_FLP+0xd7b>
mov    %esi,%ecx
and    $0xfffffffe,%ecx
movsd  0x1218(%rip),%xmm0
xor    %edx,%edx
movaps 0x123f(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x170(%rsp,%rdx,8),%xmm2
movsd  0xa8(%rsp,%rdx,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm14,%xmm3
xorps  %xmm4,%xmm4
cvtsd2ss %xmm2,%xmm4
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
xorps  %xmm1,%xmm4
movss  %xmm4,(%rbx,%rdx,4)
movsd  0x178(%rsp,%rdx,8),%xmm0
lea    0x2(%rdx),%rax
movsd  0xb0(%rsp,%rdx,8),%xmm14
mulsd  %xmm0,%xmm14
addsd  %xmm3,%xmm14
xorps  %xmm3,%xmm3
cvtsd2ss %xmm0,%xmm3
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
xorps  %xmm1,%xmm3
movss  %xmm3,0x4(%rbx,%rdx,4)
mov    %rax,%rdx
cmp    %rax,%rcx
jne    1e10 <silk_burg_modified_FLP+0xcc0>
test   $0x1,%sil
movsd  0x8(%rsp),%xmm1
je     1ecb <silk_burg_modified_FLP+0xd7b>
movsd  0x170(%rsp,%rax,8),%xmm1
movsd  0xa8(%rsp,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm14
xorps  %xmm2,%xmm2
cvtsd2ss %xmm1,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm1
xorps  0x117a(%rip),%xmm2
movss  %xmm2,(%rbx,%rax,4)
mulsd  0x114d(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm14,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
add    $0x488,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %esi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2029 <silk_burg_modified_FLP+0xed9>
and    %rdx,%rdi
xor    %ecx,%ecx
movapd 0x1121(%rip),%xmm0
nop
cvtpd2ps 0x170(%rsp,%rcx,8),%xmm1
cvtpd2ps 0x180(%rsp,%rcx,8),%xmm2
xorpd  %xmm0,%xmm1
xorpd  %xmm0,%xmm2
unpcklpd %xmm2,%xmm1
movupd %xmm1,(%rbx,%rcx,4)
cvtpd2ps 0x190(%rsp,%rcx,8),%xmm1
cvtpd2ps 0x1a0(%rsp,%rcx,8),%xmm2
xorpd  %xmm0,%xmm1
xorpd  %xmm0,%xmm2
unpcklpd %xmm2,%xmm1
movupd %xmm1,0x10(%rbx,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1f20 <silk_burg_modified_FLP+0xdd0>
test   $0x1,%dl
je     1fa1 <silk_burg_modified_FLP+0xe51>
cvtpd2ps 0x170(%rsp,%rcx,8),%xmm0
cvtpd2ps 0x180(%rsp,%rcx,8),%xmm1
movapd 0x10b0(%rip),%xmm2
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rbx,%rcx,4)
cmp    %rsi,%rax
je     1fce <silk_burg_modified_FLP+0xe7e>
movaps 0x1093(%rip),%xmm0
nopl   (%rax)
movsd  0x170(%rsp,%rax,8),%xmm1
cvtsd2ss %xmm1,%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1fb0 <silk_burg_modified_FLP+0xe60>
cmpl   $0x0,0x34(%rsp)
jle    2018 <silk_burg_modified_FLP+0xec8>
movsd  0x8(%rsp),%xmm1
mov    0x20(%rsp),%rbx
movsd  %xmm1,0x8(%rsp)
mov    %rbx,%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1070 <silk_energy_FLP@plt>
movsd  0x8(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
subsd  %xmm0,%xmm1
add    %r15,%rbx
add    $0xffffffffffffffff,%rbp
jne    1fe0 <silk_burg_modified_FLP+0xe90>
mulsd  0x10(%rsp),%xmm1
jmp    1edc <silk_burg_modified_FLP+0xd8c>
movsd  0x8(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm1
jmp    1edc <silk_burg_modified_FLP+0xd8c>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1f76 <silk_burg_modified_FLP+0xe26>
jmp    1fa1 <silk_burg_modified_FLP+0xe51>

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

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