void SKP_Silk_burg_modified(int *res_nrg, int *res_nrg_Q, int A_Q16[],
                            const short x[], const int subfr_length,
                            const int nb_subfr, const int WhiteNoiseFrac_Q32,
                            const int D) {
  int k, n, s, lz, rshifts, rshifts_extra;
  int C0, num, nrg, rc_Q31, Atmp_QA, Atmp1, tmp1, tmp2, x1, x2;
  const short *x_ptr;
  int C_first_row[16];
  int C_last_row[16];
  int Af_QA[16];
  int CAf[16 + 1];
  int CAb[16 + 1];
  ;
  ;
  SKP_Silk_sum_sqr_shift(&C0, &rshifts, x, nb_subfr * subfr_length);
  if (rshifts > (32 - 24)) {
    C0 = ((C0) << (rshifts - (32 - 24)));
    ;
    rshifts = (32 - 24);
  } else {
    lz = SKP_Silk_CLZ32(C0) - 1;
    rshifts_extra = 2 - lz;
    if (rshifts_extra > 0) {
      rshifts_extra =
          (((rshifts_extra) < ((32 - 24) - rshifts)) ? (rshifts_extra)
                                                     : ((32 - 24) - rshifts));
      C0 = ((C0) >> (rshifts_extra));
    } else {
      rshifts_extra = (((rshifts_extra) > (-16 - rshifts)) ? (rshifts_extra)
                                                           : (-16 - rshifts));
      C0 = ((C0) << (-rshifts_extra));
    }
    rshifts += rshifts_extra;
  }
  memset((C_first_row), (0), (16 * sizeof(int)));
  if (rshifts > 0) {
    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] += (int)((SKP_Silk_inner_prod16_aligned_64(
                                        x_ptr, x_ptr + n, subfr_length - n)) >>
                                    (rshifts));
      }
    }
  } else {
    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] +=
            ((SKP_Silk_inner_prod_aligned(x_ptr, x_ptr + n, subfr_length - n))
             << (-rshifts));
      }
    }
  }
  memcpy((C_last_row), (C_first_row), (16 * sizeof(int)));
  CAb[0] = CAf[0] =
      C0 + (int)((((long long)((WhiteNoiseFrac_Q32)) * ((C0)))) >> (32)) + 1;
  for (n = 0; n < D; n++) {
    if (rshifts > -2) {
      for (s = 0; s < nb_subfr; s++) {
        x_ptr = x + s * subfr_length;
        x1 = -(((int)x_ptr[n]) << (16 - rshifts));
        x2 = -(((int)x_ptr[subfr_length - n - 1]) << (16 - rshifts));
        tmp1 = (((int)x_ptr[n]) << (24 - 16));
        tmp2 = (((int)x_ptr[subfr_length - n - 1]) << (24 - 16));
        for (k = 0; k < n; k++) {
          C_first_row[k] =
              ((C_first_row[k]) +
               ((((x1) >> 16) * (int)((short)(x_ptr[n - k - 1]))) +
                ((((x1)&0x0000FFFF) * (int)((short)(x_ptr[n - k - 1]))) >>
                 16)));
          C_last_row[k] =
              ((C_last_row[k]) +
               ((((x2) >> 16) * (int)((short)(x_ptr[subfr_length - n + k]))) +
                ((((x2)&0x0000FFFF) *
                  (int)((short)(x_ptr[subfr_length - n + k]))) >>
                 16)));
          Atmp_QA = Af_QA[k];
          tmp1 =
              ((tmp1) +
               ((((Atmp_QA) >> 16) * (int)((short)(x_ptr[n - k - 1]))) +
                ((((Atmp_QA)&0x0000FFFF) * (int)((short)(x_ptr[n - k - 1]))) >>
                 16)));
          tmp2 = ((tmp2) + ((((Atmp_QA) >> 16) *
                             (int)((short)(x_ptr[subfr_length - n + k]))) +
                            ((((Atmp_QA)&0x0000FFFF) *
                              (int)((short)(x_ptr[subfr_length - n + k]))) >>
                             16)));
        }
        tmp1 = ((-tmp1) << (32 - 24 - rshifts));
        tmp2 = ((-tmp2) << (32 - 24 - rshifts));
        for (k = 0; k <= n; k++) {
          CAf[k] =
              ((CAf[k]) +
               ((((tmp1) >> 16) * (int)((short)(x_ptr[n - k]))) +
                ((((tmp1)&0x0000FFFF) * (int)((short)(x_ptr[n - k]))) >> 16)));
          CAb[k] =
              ((CAb[k]) + ((((tmp2) >> 16) *
                            (int)((short)(x_ptr[subfr_length - n + k - 1]))) +
                           ((((tmp2)&0x0000FFFF) *
                             (int)((short)(x_ptr[subfr_length - n + k - 1]))) >>
                            16)));
        }
      }
    } else {
      for (s = 0; s < nb_subfr; s++) {
        x_ptr = x + s * subfr_length;
        x1 = -(((int)x_ptr[n]) << (-rshifts));
        x2 = -(((int)x_ptr[subfr_length - n - 1]) << (-rshifts));
        tmp1 = (((int)x_ptr[n]) << (17));
        tmp2 = (((int)x_ptr[subfr_length - n - 1]) << (17));
        for (k = 0; k < n; k++) {
          C_first_row[k] = (((C_first_row[k])) + (((x1) * (x_ptr[n - k - 1]))));
          C_last_row[k] =
              (((C_last_row[k])) + (((x2) * (x_ptr[subfr_length - n + k]))));
          Atmp1 = ((24 - 17) == 1 ? ((Af_QA[k]) >> 1) + ((Af_QA[k]) & 1)
                                  : (((Af_QA[k]) >> ((24 - 17) - 1)) + 1) >> 1);
          tmp1 = (((tmp1)) + (((x_ptr[n - k - 1]) * (Atmp1))));
          tmp2 = (((tmp2)) + (((x_ptr[subfr_length - n + k]) * (Atmp1))));
        }
        tmp1 = -tmp1;
        tmp2 = -tmp2;
        for (k = 0; k <= n; k++) {
          CAf[k] =
              ((((((CAf[k])) +
                  (((((tmp1)) >> 16) *
                    (int)((short)(((((int)x_ptr[n - k]) << (-rshifts - 1)))))) +
                   (((((tmp1)) & 0x0000FFFF) *
                     (int)((
                         short)(((((int)x_ptr[n - k]) << (-rshifts - 1)))))) >>
                    16))))) +
               ((((tmp1)) *
                 (((16) == 1
                       ? ((((((int)x_ptr[n - k]) << (-rshifts - 1)))) >> 1) +
                             ((((((int)x_ptr[n - k]) << (-rshifts - 1)))) & 1)
                       : (((((((int)x_ptr[n - k]) << (-rshifts - 1)))) >>
                           ((16) - 1)) +
                          1) >>
                             1)))));
          CAb[k] =
              ((((((CAb[k])) +
                  (((((tmp2)) >> 16) *
                    (int)((short)(((((int)x_ptr[subfr_length - n + k - 1])
                                    << (-rshifts - 1)))))) +
                   (((((tmp2)) & 0x0000FFFF) *
                     (int)((short)(((((int)x_ptr[subfr_length - n + k - 1])
                                     << (-rshifts - 1)))))) >>
                    16))))) +
               ((((tmp2)) *
                 (((16) == 1 ? ((((((int)x_ptr[subfr_length - n + k - 1])
                                   << (-rshifts - 1)))) >>
                                1) +
                                   ((((((int)x_ptr[subfr_length - n + k - 1])
                                       << (-rshifts - 1)))) &
                                    1)
                             : (((((((int)x_ptr[subfr_length - n + k - 1])
                                    << (-rshifts - 1)))) >>
                                 ((16) - 1)) +
                                1) >>
                                   1)))));
        }
      }
    }
    tmp1 = C_first_row[n];
    tmp2 = C_last_row[n];
    num = 0;
    nrg = ((CAb[0]) + (CAf[0]));
    for (k = 0; k < n; k++) {
      Atmp_QA = Af_QA[k];
      lz = SKP_Silk_CLZ32((((Atmp_QA) > 0) ? (Atmp_QA) : -(Atmp_QA))) - 1;
      lz = (((32 - 24) < (lz)) ? (32 - 24) : (lz));
      Atmp1 = ((Atmp_QA) << (lz));
      tmp1 = (((tmp1)) +
              (((((int)((((long long)((C_last_row[n - k - 1])) * ((Atmp1)))) >>
                        (32))))
                << ((32 - 24 - lz)))));
      tmp2 = (((tmp2)) +
              (((((int)((((long long)((C_first_row[n - k - 1])) * ((Atmp1)))) >>
                        (32))))
                << ((32 - 24 - lz)))));
      num = (((num)) +
             (((((int)((((long long)((CAb[n - k])) * ((Atmp1)))) >> (32))))
               << ((32 - 24 - lz)))));
      nrg =
          (((nrg)) + (((((int)((((long long)((((CAb[k + 1]) + (CAf[k + 1])))) *
                                 ((Atmp1)))) >>
                               (32))))
                       << ((32 - 24 - lz)))));
    }
    CAf[n + 1] = tmp1;
    CAb[n + 1] = tmp2;
    num = ((num) + (tmp2));
    num = ((-num) << (1));
    if ((((num) > 0) ? (num) : -(num)) < nrg) {
      rc_Q31 = SKP_DIV32_varQ(num, nrg, 31);
    } else {
      memset((&Af_QA[n]), (0), ((D - n) * sizeof(int)));
      ;
      break;
    }
    for (k = 0; k < (n + 1) >> 1; k++) {
      tmp1 = Af_QA[k];
      tmp2 = Af_QA[n - k - 1];
      Af_QA[k] =
          (((tmp1)) + (((((int)((((long long)((tmp2)) * ((rc_Q31)))) >> (32))))
                        << ((1)))));
      Af_QA[n - k - 1] =
          (((tmp2)) + (((((int)((((long long)((tmp1)) * ((rc_Q31)))) >> (32))))
                        << ((1)))));
    }
    Af_QA[n] = ((rc_Q31) >> (31 - 24));
    for (k = 0; k <= n + 1; k++) {
      tmp1 = CAf[k];
      tmp2 = CAb[n - k + 1];
      CAf[k] =
          (((tmp1)) + (((((int)((((long long)((tmp2)) * ((rc_Q31)))) >> (32))))
                        << ((1)))));
      CAb[n - k + 1] =
          (((tmp2)) + (((((int)((((long long)((tmp1)) * ((rc_Q31)))) >> (32))))
                        << ((1)))));
    }
  }
  nrg = CAf[0];
  tmp1 = 1 << 16;
  for (k = 0; k < D; k++) {
    Atmp1 = ((24 - 16) == 1 ? ((Af_QA[k]) >> 1) + ((Af_QA[k]) & 1)
                            : (((Af_QA[k]) >> ((24 - 16) - 1)) + 1) >> 1);
    nrg = ((((((nrg)) +
              (((((CAf[k + 1])) >> 16) * (int)((short)((Atmp1)))) +
               (((((CAf[k + 1])) & 0x0000FFFF) * (int)((short)((Atmp1)))) >>
                16))))) +
           ((((CAf[k + 1])) *
             (((16) == 1 ? (((Atmp1)) >> 1) + (((Atmp1)) & 1)
                         : ((((Atmp1)) >> ((16) - 1)) + 1) >> 1)))));
    tmp1 =
        ((((((tmp1)) +
            (((((Atmp1)) >> 16) * (int)((short)((Atmp1)))) +
             (((((Atmp1)) & 0x0000FFFF) * (int)((short)((Atmp1)))) >> 16))))) +
         ((((Atmp1)) * (((16) == 1 ? (((Atmp1)) >> 1) + (((Atmp1)) & 1)
                                   : ((((Atmp1)) >> ((16) - 1)) + 1) >> 1)))));
    A_Q16[k] = -Atmp1;
  }
  *res_nrg =
      ((((((nrg)) +
          ((((((int)((((long long)((WhiteNoiseFrac_Q32)) * ((C0)))) >>
                     (32)))) >>
             16) *
            (int)((short)((-tmp1)))) +
           ((((((int)((((long long)((WhiteNoiseFrac_Q32)) * ((C0)))) >>
                      (32)))) &
              0x0000FFFF) *
             (int)((short)((-tmp1)))) >>
            16))))) +
       (((((int)((((long long)((WhiteNoiseFrac_Q32)) * ((C0)))) >> (32)))) *
         (((16) == 1 ? (((-tmp1)) >> 1) + (((-tmp1)) & 1)
                     : ((((-tmp1)) >> ((16) - 1)) + 1) >> 1)))));
  *res_nrg_Q = -rshifts;
}


x86 assembly (clang, -O0):
<SKP_Silk_burg_modified>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
lea    -0x44(%rbp),%rdi
lea    -0x3c(%rbp),%rsi
mov    $0x0,%al
call   1060 <SKP_Silk_sum_sqr_shift@plt>
cmpl   $0x8,-0x3c(%rbp)
jle    11d7 <SKP_Silk_burg_modified+0x67>
mov    -0x44(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x8,%ecx
shl    %cl,%eax
mov    %eax,-0x44(%rbp)
movl   $0x8,-0x3c(%rbp)
jmp    1292 <SKP_Silk_burg_modified+0x122>
mov    -0x44(%rbp),%edi
mov    $0x0,%al
call   1030 <SKP_Silk_CLZ32@plt>
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    $0x2,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    1244 <SKP_Silk_burg_modified+0xd4>
mov    -0x40(%rbp),%eax
mov    $0x8,%ecx
sub    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jge    121d <SKP_Silk_burg_modified+0xad>
mov    -0x40(%rbp),%eax
mov    %eax,-0x1d4(%rbp)
jmp    122b <SKP_Silk_burg_modified+0xbb>
mov    $0x8,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x40(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x44(%rbp)
jmp    1289 <SKP_Silk_burg_modified+0x119>
mov    -0x40(%rbp),%eax
mov    $0xfffffff0,%ecx
sub    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jle    1265 <SKP_Silk_burg_modified+0xf5>
mov    -0x40(%rbp),%eax
mov    %eax,-0x1d8(%rbp)
jmp    1273 <SKP_Silk_burg_modified+0x103>
mov    $0xfffffff0,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x1d8(%rbp)
mov    -0x1d8(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
xor    %ecx,%ecx
sub    -0x40(%rbp),%ecx
shl    %cl,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
cmpl   $0x0,-0x3c(%rbp)
jle    1356 <SKP_Silk_burg_modified+0x1e6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1351 <SKP_Silk_burg_modified+0x1e1>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    133e <SKP_Silk_burg_modified+0x1ce>
mov    -0x70(%rbp),%rdi
mov    -0x70(%rbp),%rsi
movslq -0x30(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x24(%rbp),%edx
sub    -0x30(%rbp),%edx
mov    $0x0,%al
call   1090 <SKP_Silk_inner_prod16_aligned_64@plt>
mov    -0x3c(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
add    -0xb0(%rbp,%rax,4),%ecx
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12e2 <SKP_Silk_burg_modified+0x172>
jmp    1343 <SKP_Silk_burg_modified+0x1d3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b6 <SKP_Silk_burg_modified+0x146>
jmp    13ff <SKP_Silk_burg_modified+0x28f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13fa <SKP_Silk_burg_modified+0x28a>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13e7 <SKP_Silk_burg_modified+0x277>
mov    -0x70(%rbp),%rdi
mov    -0x70(%rbp),%rsi
movslq -0x30(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x24(%rbp),%edx
sub    -0x30(%rbp),%edx
mov    $0x0,%al
call   1080 <SKP_Silk_inner_prod_aligned@plt>
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
add    -0xb0(%rbp,%rax,4),%ecx
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1389 <SKP_Silk_burg_modified+0x219>
jmp    13ec <SKP_Silk_burg_modified+0x27c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    135d <SKP_Silk_burg_modified+0x1ed>
jmp    13ff <SKP_Silk_burg_modified+0x28f>
lea    -0xf0(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
mov    -0x44(%rbp),%eax
movslq 0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   %rdx,%rcx
sar    $0x20,%rcx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
mov    %eax,-0x1d0(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1e81 <SKP_Silk_burg_modified+0xd11>
cmpl   $0xfffffffe,-0x3c(%rbp)
jle    177e <SKP_Silk_burg_modified+0x60e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1779 <SKP_Silk_burg_modified+0x609>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    $0x10,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
mov    $0x10,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0x8,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
shl    $0x8,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    166d <SKP_Silk_burg_modified+0x4fd>
movslq -0x2c(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%ecx
mov    -0x64(%rbp),%eax
sar    $0x10,%eax
mov    -0x70(%rbp),%rdx
mov    -0x30(%rbp),%esi
sub    -0x2c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%eax
mov    -0x64(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rsi
mov    -0x30(%rbp),%edi
sub    -0x2c(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
mov    -0xf0(%rbp,%rax,4),%ecx
mov    -0x68(%rbp),%eax
sar    $0x10,%eax
mov    -0x70(%rbp),%rdx
mov    -0x24(%rbp),%esi
sub    -0x30(%rbp),%esi
add    -0x2c(%rbp),%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%eax
mov    -0x68(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rsi
mov    -0x24(%rbp),%edi
sub    -0x30(%rbp),%edi
add    -0x2c(%rbp),%edi
movslq %edi,%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x54(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x70(%rbp),%rdx
mov    -0x30(%rbp),%esi
sub    -0x2c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x54(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rsi
mov    -0x30(%rbp),%edi
sub    -0x2c(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x54(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x70(%rbp),%rdx
mov    -0x24(%rbp),%esi
sub    -0x30(%rbp),%esi
add    -0x2c(%rbp),%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x54(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rsi
mov    -0x24(%rbp),%edi
sub    -0x30(%rbp),%edi
add    -0x2c(%rbp),%edi
movslq %edi,%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14fd <SKP_Silk_burg_modified+0x38d>
xor    %eax,%eax
sub    -0x5c(%rbp),%eax
mov    $0x8,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %eax,-0x5c(%rbp)
xor    %eax,%eax
sub    -0x60(%rbp),%eax
mov    $0x8,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1766 <SKP_Silk_burg_modified+0x5f6>
movslq -0x2c(%rbp),%rax
mov    -0x180(%rbp,%rax,4),%ecx
mov    -0x5c(%rbp),%eax
sar    $0x10,%eax
mov    -0x70(%rbp),%rdx
mov    -0x30(%rbp),%esi
sub    -0x2c(%rbp),%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%eax
mov    -0x5c(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rsi
mov    -0x30(%rbp),%edi
sub    -0x2c(%rbp),%edi
movslq %edi,%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x180(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%ecx
mov    -0x60(%rbp),%eax
sar    $0x10,%eax
mov    -0x70(%rbp),%rdx
mov    -0x24(%rbp),%esi
sub    -0x30(%rbp),%esi
add    -0x2c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%eax
mov    -0x60(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rsi
mov    -0x24(%rbp),%edi
sub    -0x30(%rbp),%edi
add    -0x2c(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x1d0(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1698 <SKP_Silk_burg_modified+0x528>
jmp    176b <SKP_Silk_burg_modified+0x5fb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    145f <SKP_Silk_burg_modified+0x2ef>
jmp    1ac9 <SKP_Silk_burg_modified+0x959>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ac4 <SKP_Silk_burg_modified+0x954>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0x11,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
shl    $0x11,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    18f2 <SKP_Silk_burg_modified+0x782>
movslq -0x2c(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%ecx
mov    -0x64(%rbp),%eax
mov    -0x70(%rbp),%rdx
mov    -0x30(%rbp),%esi
sub    -0x2c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
mov    -0xf0(%rbp,%rax,4),%ecx
mov    -0x68(%rbp),%eax
mov    -0x70(%rbp),%rdx
mov    -0x24(%rbp),%esi
sub    -0x30(%rbp),%esi
add    -0x2c(%rbp),%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
sar    $0x6,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x70(%rbp),%rcx
mov    -0x30(%rbp),%edx
sub    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
imul   -0x58(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x70(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
imul   -0x58(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    181d <SKP_Silk_burg_modified+0x6ad>
xor    %eax,%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
xor    %eax,%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1ab1 <SKP_Silk_burg_modified+0x941>
movslq -0x2c(%rbp),%rax
mov    -0x180(%rbp,%rax,4),%eax
mov    -0x5c(%rbp),%ecx
sar    $0x10,%ecx
mov    %ecx,-0x1f0(%rbp)
mov    -0x70(%rbp),%rcx
mov    -0x30(%rbp),%edx
sub    -0x2c(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%edx
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%edx
mov    -0x1f0(%rbp),%ecx
movswl %dx,%edx
imul   %edx,%ecx
mov    %ecx,-0x1ec(%rbp)
mov    -0x5c(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rcx
mov    -0x30(%rbp),%esi
sub    -0x2c(%rbp),%esi
movslq %esi,%rsi
movswl (%rcx,%rsi,2),%esi
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%esi
mov    -0x1ec(%rbp),%ecx
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x1e8(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x70(%rbp),%rcx
mov    -0x30(%rbp),%edx
sub    -0x2c(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%edx
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%edx
mov    -0x1e8(%rbp),%ecx
sar    $0xf,%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x180(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
mov    -0x1d0(%rbp,%rax,4),%eax
mov    -0x60(%rbp),%ecx
sar    $0x10,%ecx
mov    %ecx,-0x1e4(%rbp)
mov    -0x70(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%edx
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%edx
mov    -0x1e4(%rbp),%ecx
movswl %dx,%edx
imul   %edx,%ecx
mov    %ecx,-0x1e0(%rbp)
mov    -0x60(%rbp),%edx
and    $0xffff,%edx
mov    -0x70(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    -0x30(%rbp),%esi
add    -0x2c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movswl (%rcx,%rsi,2),%esi
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%esi
mov    -0x1e0(%rbp),%ecx
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x1dc(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x70(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%edx
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
shl    %cl,%edx
mov    -0x1dc(%rbp),%ecx
sar    $0xf,%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x1d0(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1909 <SKP_Silk_burg_modified+0x799>
jmp    1ab6 <SKP_Silk_burg_modified+0x946>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1785 <SKP_Silk_burg_modified+0x615>
jmp    1ac9 <SKP_Silk_burg_modified+0x959>
movslq -0x30(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%eax
mov    %eax,-0x5c(%rbp)
movslq -0x30(%rbp),%rax
mov    -0xf0(%rbp,%rax,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x1d0(%rbp),%eax
add    -0x180(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1c7f <SKP_Silk_burg_modified+0xb0f>
movslq -0x2c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
jle    1b34 <SKP_Silk_burg_modified+0x9c4>
mov    -0x54(%rbp),%eax
mov    %eax,-0x1f4(%rbp)
jmp    1b3f <SKP_Silk_burg_modified+0x9cf>
xor    %eax,%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x1f4(%rbp)
mov    -0x1f4(%rbp),%edi
mov    $0x0,%al
call   1030 <SKP_Silk_CLZ32@plt>
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    $0x8,%eax
cmp    -0x38(%rbp),%eax
jge    1b70 <SKP_Silk_burg_modified+0xa00>
mov    $0x8,%eax
mov    %eax,-0x1f8(%rbp)
jmp    1b79 <SKP_Silk_burg_modified+0xa09>
mov    -0x38(%rbp),%eax
mov    %eax,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x38(%rbp),%ecx
shl    %cl,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movslq -0xf0(%rbp,%rcx,4),%rcx
ff
movslq -0x58(%rbp),%rdx
imul   %rdx,%rcx
sar    $0x20,%rcx
mov    %ecx,%edx
mov    $0x8,%ecx
sub    -0x38(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movslq -0xb0(%rbp,%rcx,4),%rcx
ff
movslq -0x58(%rbp),%rdx
imul   %rdx,%rcx
sar    $0x20,%rcx
mov    %ecx,%edx
mov    $0x8,%ecx
sub    -0x38(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movslq -0x1d0(%rbp,%rcx,4),%rcx
ff
movslq -0x58(%rbp),%rdx
imul   %rdx,%rcx
sar    $0x20,%rcx
mov    %ecx,%edx
mov    $0x8,%ecx
sub    -0x38(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    -0x1d0(%rbp,%rcx,4),%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
add    -0x180(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
movslq -0x58(%rbp),%rdx
imul   %rdx,%rcx
sar    $0x20,%rcx
mov    %ecx,%edx
mov    $0x8,%ecx
sub    -0x38(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b02 <SKP_Silk_burg_modified+0x992>
mov    -0x5c(%rbp),%ecx
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x180(%rbp,%rax,4)
mov    -0x60(%rbp),%ecx
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x1d0(%rbp,%rax,4)
mov    -0x48(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x48(%rbp)
xor    %eax,%eax
sub    -0x48(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jle    1ccf <SKP_Silk_burg_modified+0xb5f>
mov    -0x48(%rbp),%eax
mov    %eax,-0x1fc(%rbp)
jmp    1cda <SKP_Silk_burg_modified+0xb6a>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x1fc(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1d03 <SKP_Silk_burg_modified+0xb93>
mov    -0x48(%rbp),%edi
mov    -0x4c(%rbp),%esi
mov    $0x1f,%edx
mov    $0x0,%al
call   1070 <SKP_DIV32_varQ@plt>
mov    %eax,-0x50(%rbp)
jmp    1d2e <SKP_Silk_burg_modified+0xbbe>
movslq -0x30(%rbp),%rax
lea    -0x130(%rbp),%rdi
shl    $0x2,%rax
add    %rax,%rdi
mov    0x18(%rbp),%eax
sub    -0x30(%rbp),%eax
movslq %eax,%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
jmp    1e81 <SKP_Silk_burg_modified+0xd11>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
cmp    %ecx,%eax
jge    1dc7 <SKP_Silk_burg_modified+0xc57>
movslq -0x2c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%ecx
movslq -0x60(%rbp),%rax
movslq -0x50(%rbp),%rdx
imul   %rdx,%rax
sar    $0x20,%rax
shl    $0x1,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x60(%rbp),%ecx
movslq -0x5c(%rbp),%rax
movslq -0x50(%rbp),%rdx
imul   %rdx,%rax
sar    $0x20,%rax
shl    $0x1,%eax
add    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d35 <SKP_Silk_burg_modified+0xbc5>
mov    -0x50(%rbp),%ecx
sar    $0x7,%ecx
movslq -0x30(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1e6e <SKP_Silk_burg_modified+0xcfe>
movslq -0x2c(%rbp),%rax
mov    -0x180(%rbp,%rax,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x2c(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x1d0(%rbp,%rax,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%ecx
movslq -0x60(%rbp),%rax
movslq -0x50(%rbp),%rdx
imul   %rdx,%rax
sar    $0x20,%rax
shl    $0x1,%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x180(%rbp,%rax,4)
mov    -0x60(%rbp),%ecx
movslq -0x5c(%rbp),%rax
movslq -0x50(%rbp),%rdx
imul   %rdx,%rax
sar    $0x20,%rax
shl    $0x1,%eax
add    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    -0x2c(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x1d0(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ddf <SKP_Silk_burg_modified+0xc6f>
jmp    1e73 <SKP_Silk_burg_modified+0xd03>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1442 <SKP_Silk_burg_modified+0x2d2>
mov    -0x180(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x10000,-0x5c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1f84 <SKP_Silk_burg_modified+0xe14>
movslq -0x2c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
sar    $0x7,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    -0x180(%rbp,%rcx,4),%ecx
sar    $0x10,%ecx
mov    -0x58(%rbp),%edx
movswl %dx,%edx
imul   %edx,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    -0x180(%rbp,%rdx,4),%edx
and    $0xffff,%edx
mov    -0x58(%rbp),%esi
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    -0x180(%rbp,%rcx,4),%ecx
mov    -0x58(%rbp),%edx
sar    $0xf,%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x58(%rbp),%edx
movswl %dx,%edx
imul   %edx,%ecx
mov    -0x58(%rbp),%edx
and    $0xffff,%edx
mov    -0x58(%rbp),%esi
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    -0x58(%rbp),%ecx
mov    -0x58(%rbp),%edx
sar    $0xf,%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
xor    %edx,%edx
sub    -0x58(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e98 <SKP_Silk_burg_modified+0xd28>
mov    -0x4c(%rbp),%ecx
movslq 0x10(%rbp),%rax
movslq -0x44(%rbp),%rdx
imul   %rdx,%rax
sar    $0x20,%rax
sar    $0x10,%eax
xor    %edx,%edx
sub    -0x5c(%rbp),%edx
movswl %dx,%edx
imul   %edx,%eax
movslq 0x10(%rbp),%rdx
movslq -0x44(%rbp),%rsi
imul   %rsi,%rdx
sar    $0x20,%rdx
and    $0xffff,%edx
xor    %esi,%esi
sub    -0x5c(%rbp),%esi
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%eax
add    %eax,%ecx
movslq 0x10(%rbp),%rax
movslq -0x44(%rbp),%rdx
imul   %rdx,%rax
sar    $0x20,%rax
xor    %edx,%edx
sub    -0x5c(%rbp),%edx
sar    $0xf,%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%eax
add    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
add    $0x200,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SKP_Silk_burg_modified>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x398,%rsp
mov    %r9d,%ebx
mov    %rcx,%rax
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%rbp
mov    %r9d,%ecx
mov    %r8,0x50(%rsp)
imul   %r8d,%ecx
lea    0x8(%rsp),%rdi
lea    0x4(%rsp),%rsi
mov    %rax,0x10(%rsp)
mov    %rax,%rdx
xor    %eax,%eax
call   1050 <SKP_Silk_sum_sqr_shift@plt>
mov    0x4(%rsp),%ecx
mov    0x8(%rsp),%edi
cmp    $0x9,%ecx
mov    %ebx,0x6c(%rsp)
mov    %r12,0x2c8(%rsp)
mov    %rbp,0x2c0(%rsp)
mov    %r14,0x120(%rsp)
jl     1209 <SKP_Silk_burg_modified+0xa9>
add    $0xf8,%cl
shl    %cl,%edi
mov    %edi,0x8(%rsp)
movl   $0x8,0x4(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0x110(%rsp)
mov    $0x8,%esi
jmp    127e <SKP_Silk_burg_modified+0x11e>
xor    %eax,%eax
call   1030 <SKP_Silk_CLZ32@plt>
mov    $0x3,%ecx
sub    %eax,%ecx
mov    0x4(%rsp),%esi
test   %ecx,%ecx
jle    1235 <SKP_Silk_burg_modified+0xd5>
mov    $0x8,%edx
sub    %esi,%edx
cmp    %edx,%ecx
cmovl  %ecx,%edx
mov    0x8(%rsp),%eax
mov    %edx,%ecx
sar    %cl,%eax
jmp    124b <SKP_Silk_burg_modified+0xeb>
mov    $0xfffffff0,%edx
sub    %esi,%edx
cmp    %edx,%ecx
cmovg  %ecx,%edx
mov    0x8(%rsp),%eax
mov    %edx,%ecx
neg    %cl
shl    %cl,%eax
mov    %eax,0x8(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0x110(%rsp)
add    %edx,%esi
mov    %esi,0x4(%rsp)
jle    134e <SKP_Silk_burg_modified+0x1ee>
mov    0x3d8(%rsp),%eax
test   %ebx,%ebx
jle    1410 <SKP_Silk_burg_modified+0x2b0>
mov    0x50(%rsp),%rcx
movslq %ecx,%rdi
add    $0x1,%eax
mov    %ebx,%edx
mov    %rdx,0x20(%rsp)
add    $0xffffffff,%ecx
mov    %ecx,0x40(%rsp)
mov    0x10(%rsp),%rcx
lea    0x2(%rcx),%r12
mov    %rdi,0x80(%rsp)
lea    (%rdi,%rdi,1),%rcx
mov    %rcx,0x70(%rsp)
lea    (%rax,%rax,1),%r13
add    $0xfffffffffffffffe,%r13
xor    %r15d,%r15d
jmp    12ea <SKP_Silk_burg_modified+0x18a>
nopl   (%rax)
mov    %r15,%rax
add    $0x1,%rax
add    0x70(%rsp),%r12
mov    %rax,%r15
cmp    0x20(%rsp),%rax
je     1410 <SKP_Silk_burg_modified+0x2b0>
mov    0x3d8(%rsp),%eax
test   %eax,%eax
jle    12d0 <SKP_Silk_burg_modified+0x170>
mov    %r15,%rax
imul   0x80(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,2),%rbp
xor    %r14d,%r14d
mov    0x40(%rsp),%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r12,%r14,1),%rsi
mov    %rbp,%rdi
mov    %ebx,%edx
xor    %eax,%eax
call   1080 <SKP_Silk_inner_prod16_aligned_64@plt>
mov    0x4(%rsp),%esi
mov    %esi,%ecx
sar    %cl,%eax
add    %eax,0xe0(%rsp,%r14,2)
add    $0xffffffff,%ebx
add    $0x2,%r14
cmp    %r14,%r13
jne    1320 <SKP_Silk_burg_modified+0x1c0>
jmp    12d0 <SKP_Silk_burg_modified+0x170>
test   %ebx,%ebx
mov    0x3d8(%rsp),%eax
jle    1410 <SKP_Silk_burg_modified+0x2b0>
movslq 0x50(%rsp),%rdx
add    $0x1,%eax
mov    %ebx,%ecx
mov    %rcx,0x20(%rsp)
lea    -0x1(%rdx),%ecx
mov    %ecx,0x40(%rsp)
mov    0x10(%rsp),%rcx
lea    0x2(%rcx),%r12
mov    %rdx,0x80(%rsp)
lea    (%rdx,%rdx,1),%rcx
mov    %rcx,0x70(%rsp)
lea    (%rax,%rax,1),%r13
add    $0xfffffffffffffffe,%r13
xor    %r15d,%r15d
jmp    13b6 <SKP_Silk_burg_modified+0x256>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rax
add    $0x1,%rax
add    0x70(%rsp),%r12
mov    %rax,%r15
cmp    0x20(%rsp),%rax
je     1410 <SKP_Silk_burg_modified+0x2b0>
mov    0x3d8(%rsp),%eax
test   %eax,%eax
jle    13a0 <SKP_Silk_burg_modified+0x240>
mov    %r15,%rax
imul   0x80(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,2),%rbp
xor    %r14d,%r14d
mov    0x40(%rsp),%ebx
nopl   (%rax)
lea    (%r12,%r14,1),%rsi
mov    %rbp,%rdi
mov    %ebx,%edx
xor    %eax,%eax
call   1070 <SKP_Silk_inner_prod_aligned@plt>
mov    0x4(%rsp),%esi
mov    %esi,%ecx
neg    %cl
shl    %cl,%eax
add    %eax,0xe0(%rsp,%r14,2)
add    $0xffffffff,%ebx
add    $0x2,%r14
cmp    %r14,%r13
jne    13e0 <SKP_Silk_burg_modified+0x280>
jmp    13a0 <SKP_Silk_burg_modified+0x240>
movdqa 0xe0(%rsp),%xmm0
movdqa 0xf0(%rsp),%xmm1
movdqa 0x100(%rsp),%xmm2
movdqa 0x110(%rsp),%xmm3
movdqa %xmm3,0x240(%rsp)
movdqa %xmm2,0x230(%rsp)
movdqa %xmm1,0x220(%rsp)
movdqa %xmm0,0x210(%rsp)
movslq 0x8(%rsp),%rax
movslq 0x3d0(%rsp),%rdx
mov    %rax,%rcx
mov    %rdx,0x2b8(%rsp)
imul   %rdx,%rcx
shr    $0x20,%rcx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,0x1c0(%rsp)
mov    %eax,0x330(%rsp)
mov    0x3d8(%rsp),%eax
test   %eax,%eax
jle    2be9 <SKP_Silk_burg_modified+0x1a89>
movabs $0xffffffff00000000,%rbp
ff ff ff
movabs $0x100000000,%r14
mov    0x50(%rsp),%rdx
movslq %edx,%rdi
mov    %eax,%eax
mov    %rax,0x98(%rsp)
mov    0x6c(%rsp),%ecx
mov    %ecx,%eax
mov    %rax,0x178(%rsp)
add    $0xffffffff,%edx
mov    %rdx,0x50(%rsp)
mov    0x10(%rsp),%rax
lea    -0x8(%rax),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%rdi,%rdi,1),%rdx
mov    %rdx,0x170(%rsp)
lea    -0x2(%rax),%rdx
mov    %rdx,0xb0(%rsp)
lea    -0x6(%rax),%rdx
mov    %rdx,0xa8(%rsp)
mov    %rdi,%rdx
shl    $0x20,%rdx
add    %rbp,%rdx
mov    %rdx,0xc0(%rsp)
mov    %rdi,0x90(%rsp)
lea    (%rdi,%r14,1),%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,0xc8(%rsp)
lea    0x328(%rsp),%rbx
pcmpeqd %xmm12,%xmm12
lea    0x334(%rsp),%r8
mov    $0x2,%r9d
mov    $0x1,%edx
mov    $0xffffffffffffffff,%r10
mov    %rax,0xa0(%rsp)
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
mov    %rdx,0x58(%rsp)
mov    %rdx,%r15
and    $0xfffffffffffffffc,%r15
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x148(%rsp)
mov    0x50(%rsp),%rax
sub    %r13d,%eax
cmp    $0xfffffffe,%esi
mov    %r13,0x60(%rsp)
mov    %r15,0x160(%rsp)
mov    %rbx,0x140(%rsp)
mov    %r8,0x138(%rsp)
mov    %r9,0x130(%rsp)
mov    %r10,0x128(%rsp)
jle    1f70 <SKP_Silk_burg_modified+0xe10>
test   %ecx,%ecx
jle    2790 <SKP_Silk_burg_modified+0x1630>
mov    $0x10,%ecx
sub    %esi,%ecx
mov    %ecx,0xdc(%rsp)
mov    0x90(%rsp),%r9
sub    %r13,%r9
mov    $0x8,%ecx
sub    %esi,%ecx
mov    %ecx,0xd8(%rsp)
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
lea    -0x4(%rdx),%rcx
and    %r13,%rcx
mov    %rcx,0x2d0(%rsp)
lea    (%rax,%r13,1),%ecx
cmp    %eax,%ecx
setl   %al
mov    %r13,%rcx
shr    $0x20,%rcx
setne  %cl
or     %al,%cl
mov    %cl,0xf(%rsp)
mov    0x58(%rsp),%rax
and    %rdx,%rax
mov    %rax,0x2d8(%rsp)
mov    0xa0(%rsp),%r15
mov    0xa8(%rsp),%rax
mov    %rax,0x158(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    0xb8(%rsp),%rbp
xor    %ebx,%ebx
jmp    16b3 <SKP_Silk_burg_modified+0x553>
xchg   %ax,%ax
mov    0x2e0(%rsp),%rbx
add    $0x1,%rbx
mov    0x170(%rsp),%rax
mov    0x2e8(%rsp),%rbp
add    %rax,%rbp
add    %rax,0x150(%rsp)
add    %rax,0x158(%rsp)
add    %rax,%r15
cmp    0x178(%rsp),%rbx
mov    %r12,%r9
je     2790 <SKP_Silk_burg_modified+0x1630>
mov    %rbx,%rax
imul   0x90(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,2),%rdx
mov    %rdx,0x38(%rsp)
movswl (%rdx,%r13,2),%esi
mov    %esi,%eax
mov    0xdc(%rsp),%ecx
shl    %cl,%eax
movswl -0x2(%rdx,%r9,2),%edi
mov    %edi,%edx
shl    %cl,%edx
shl    $0x8,%esi
shl    $0x8,%edi
test   %r13,%r13
mov    %r15,0x168(%rsp)
mov    %rbp,0x2e8(%rsp)
mov    %rbx,0x2e0(%rsp)
je     1d1d <SKP_Silk_burg_modified+0xbbd>
neg    %eax
neg    %edx
mov    %eax,%r8d
sar    $0x10,%r8d
mov    %edx,%ecx
sar    $0x10,%ecx
movzwl %ax,%eax
movzwl %dx,%edx
cmp    $0x8,%r13
mov    %ecx,0x1c(%rsp)
jae    1750 <SKP_Silk_burg_modified+0x5f0>
xor    %ebp,%ebp
movabs $0x100000000,%rbx
mov    %r8d,%r10d
mov    %eax,%r14d
mov    %edx,%r8d
jmp    1c4a <SKP_Silk_burg_modified+0xaea>
nopl   0x0(%rax,%rax,1)
movd   %edi,%xmm0
movdqa %xmm0,0x40(%rsp)
movd   %esi,%xmm13
mov    %r8d,0xd4(%rsp)
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x270(%rsp)
mov    %eax,%r12d
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x260(%rsp)
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x250(%rsp)
mov    %edx,%r8d
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x380(%rsp)
pxor   %xmm8,%xmm8
xor    %ebx,%ebx
xor    %r11d,%r11d
pxor   %xmm7,%xmm7
movabs $0x800000000,%rsi
mov    0x148(%rsp),%rdx
mov    0x38(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movq   0x0(%rbp),%xmm0
pshuflw $0x1b,%xmm0,%xmm9
movq   -0x8(%rbp),%xmm0
pshuflw $0x1b,%xmm0,%xmm14
punpcklwd %xmm9,%xmm12
psrad  $0x10,%xmm12
punpcklwd %xmm14,%xmm4
psrad  $0x10,%xmm4
movdqa 0x270(%rsp),%xmm3
movdqa %xmm3,%xmm0
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm12,%xmm15
pshufd $0xf5,%xmm3,%xmm2
movdqa %xmm2,%xmm1
pmuludq %xmm15,%xmm1
pshufd $0xe8,%xmm1,%xmm5
pmuludq %xmm4,%xmm3
pshufd $0xe8,%xmm3,%xmm1
pshufd $0xf5,%xmm4,%xmm3
movdqa %xmm4,%xmm10
movdqa %xmm4,0x80(%rsp)
punpckldq %xmm5,%xmm0
pmuludq %xmm3,%xmm2
movdqa %xmm3,%xmm11
movdqa %xmm3,0x2a0(%rsp)
pshufd $0xe8,%xmm2,%xmm2
movdqa 0x260(%rsp),%xmm4
movdqa %xmm4,%xmm3
pmuludq %xmm12,%xmm3
punpckldq %xmm2,%xmm1
pshufd $0xe8,%xmm3,%xmm2
pshufd $0xf5,%xmm4,%xmm3
movdqa %xmm3,%xmm5
pmuludq %xmm15,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pmuludq %xmm10,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm11,%xmm3
punpckldq %xmm5,%xmm2
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm4
paddd  0xe0(%rsp,%r11,4),%xmm0
psrad  $0x10,%xmm2
paddd  0xf0(%rsp,%r11,4),%xmm1
psrad  $0x10,%xmm4
paddd  %xmm2,%xmm0
paddd  %xmm4,%xmm1
movdqa %xmm0,0xe0(%rsp,%r11,4)
mov    %rbx,%rax
movdqa %xmm1,0xf0(%rsp,%r11,4)
sar    $0x20,%rax
add    %r9,%rax
movq   (%rcx,%rax,2),%xmm0
movdqa %xmm0,0x1a0(%rsp)
punpcklwd %xmm0,%xmm1
psrad  $0x10,%xmm1
movdqa %xmm1,0x20(%rsp)
movdqa 0x250(%rsp),%xmm3
movdqa %xmm3,%xmm0
pmuludq %xmm1,%xmm0
pshufd $0xf5,%xmm1,%xmm2
movdqa %xmm2,0x70(%rsp)
pshufd $0xe8,%xmm0,%xmm4
pshufd $0xf5,%xmm3,%xmm1
movdqa %xmm1,%xmm0
pmuludq %xmm2,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm4
movdqa %xmm4,0x1b0(%rsp)
movdqa 0x2f0(%rsp,%r11,4),%xmm11
movdqa %xmm11,%xmm10
psrad  $0x10,%xmm10
packssdw %xmm10,%xmm10
movdqa %xmm10,%xmm0
pmulhw %xmm9,%xmm0
pmullw %xmm10,%xmm9
punpcklwd %xmm0,%xmm9
paddd  %xmm13,%xmm9
movdqa %xmm9,0x290(%rsp)
movq   0x8(%rcx,%rax,2),%xmm0
movdqa %xmm0,0x180(%rsp)
punpcklwd %xmm0,%xmm2
psrad  $0x10,%xmm2
movdqa %xmm3,%xmm0
pmuludq %xmm2,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm2,%xmm3
movdqa %xmm3,0x190(%rsp)
pmuludq %xmm3,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa 0x300(%rsp,%r11,4),%xmm9
movdqa %xmm9,%xmm1
psrad  $0x10,%xmm1
packssdw %xmm1,%xmm1
movdqa %xmm1,%xmm3
pmulhw %xmm14,%xmm3
pmullw %xmm1,%xmm14
punpcklwd %xmm3,%xmm14
paddd  %xmm7,%xmm14
movdqa %xmm14,0x280(%rsp)
movdqa 0x15e4(%rip),%xmm4
pand   %xmm4,%xmm11
pmuludq %xmm11,%xmm12
pshufd $0xf5,%xmm11,%xmm3
pmuludq %xmm3,%xmm15
pshufd $0xe8,%xmm12,%xmm13
pshufd $0xe8,%xmm15,%xmm7
punpckldq %xmm7,%xmm13
movdqa 0x380(%rsp),%xmm5
movdqa %xmm5,%xmm7
pmuludq 0x20(%rsp),%xmm7
pshufd $0xe8,%xmm7,%xmm14
pshufd $0xf5,%xmm5,%xmm15
movdqa %xmm15,%xmm7
pmuludq 0x70(%rsp),%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm14
pand   %xmm4,%xmm9
movdqa 0x80(%rsp),%xmm4
pmuludq %xmm9,%xmm4
pshufd $0xe8,%xmm4,%xmm7
pshufd $0xf5,%xmm9,%xmm6
movdqa %xmm6,0x80(%rsp)
movdqa 0x2a0(%rsp),%xmm4
pmuludq %xmm6,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm7
psrad  $0x10,%xmm13
paddd  0x290(%rsp),%xmm13
psrad  $0x10,%xmm7
paddd  0x280(%rsp),%xmm7
movdqa %xmm10,%xmm4
movdqa 0x1a0(%rsp),%xmm12
pmulhw %xmm12,%xmm4
pmullw %xmm12,%xmm10
punpcklwd %xmm4,%xmm10
paddd  0x40(%rsp),%xmm10
movdqa %xmm1,%xmm4
movdqa 0x180(%rsp),%xmm6
pmulhw %xmm6,%xmm4
pmullw %xmm6,%xmm1
punpcklwd %xmm4,%xmm1
paddd  %xmm8,%xmm1
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm4
movdqa 0x190(%rsp),%xmm6
pmuludq %xmm6,%xmm15
pshufd $0xe8,%xmm15,%xmm5
punpckldq %xmm5,%xmm4
psrad  $0x10,%xmm14
movdqa 0x1b0(%rsp),%xmm5
paddd  0x210(%rsp,%r11,4),%xmm5
paddd  %xmm14,%xmm5
psrad  $0x10,%xmm4
paddd  0x220(%rsp,%r11,4),%xmm0
paddd  %xmm4,%xmm0
pmuludq 0x20(%rsp),%xmm11
pmuludq 0x70(%rsp),%xmm3
pshufd $0xe8,%xmm11,%xmm4
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm4
pmuludq %xmm2,%xmm9
movdqa 0x80(%rsp),%xmm2
pmuludq %xmm6,%xmm2
movdqa %xmm5,0x210(%rsp,%r11,4)
pshufd $0xe8,%xmm9,%xmm8
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm8
psrad  $0x10,%xmm4
paddd  %xmm10,%xmm4
movdqa %xmm4,0x40(%rsp)
psrad  $0x10,%xmm8
paddd  %xmm1,%xmm8
movdqa %xmm0,0x220(%rsp,%r11,4)
add    $0x8,%r11
add    $0xfffffffffffffff0,%rbp
add    %rsi,%rbx
cmp    %r11,%rdx
jne    17e0 <SKP_Silk_burg_modified+0x680>
paddd  %xmm13,%xmm7
pshufd $0xee,%xmm7,%xmm0
paddd  %xmm7,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
paddd  0x40(%rsp),%xmm8
pshufd $0xee,%xmm8,%xmm0
paddd  %xmm8,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edi
mov    0x2d0(%rsp),%rax
mov    %rax,%rbp
cmp    %rax,%r13
movabs $0x100000000,%rbx
mov    0xd4(%rsp),%r10d
mov    %r12d,%r14d
je     1d1d <SKP_Silk_burg_modified+0xbbd>
mov    %rbp,%r13
shl    $0x20,%r13
mov    0x150(%rsp),%rax
sub    %rbp,%rax
sub    %rbp,%rax
mov    %edi,%r11d
mov    %esi,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
movswl (%rax),%esi
mov    %r10d,%edx
imul   %esi,%edx
mov    %rbx,%r15
mov    %r14d,%ebx
imul   %esi,%ebx
sar    $0x10,%ebx
add    0xe0(%rsp,%rbp,4),%edx
add    %ebx,%edx
mov    %edx,0xe0(%rsp,%rbp,4)
mov    %r13,%rdx
sar    $0x20,%rdx
add    %r9,%rdx
mov    0x38(%rsp),%rcx
movswl (%rcx,%rdx,2),%edx
mov    0x1c(%rsp),%ebx
imul   %edx,%ebx
mov    %r10d,%ecx
mov    %r8d,%r10d
imul   %edx,%r10d
add    0x210(%rsp,%rbp,4),%ebx
sar    $0x10,%r10d
add    %r10d,%ebx
mov    %ecx,%r10d
mov    %ebx,0x210(%rsp,%rbp,4)
mov    0x2f0(%rsp,%rbp,4),%edi
mov    %edi,%ebx
sar    $0x10,%ebx
mov    %ebx,%ecx
imul   %esi,%ecx
add    %r12d,%ecx
movzwl %di,%edi
imul   %edi,%esi
sar    $0x10,%esi
add    %ecx,%esi
imul   %edx,%ebx
add    %r11d,%ebx
imul   %edx,%edi
sar    $0x10,%edi
add    %ebx,%edi
mov    %r15,%rbx
add    $0x1,%rbp
add    %r15,%r13
add    $0xfffffffffffffffe,%rax
mov    %edi,%r11d
mov    %esi,%r12d
cmp    %rbp,0x60(%rsp)
jne    1c70 <SKP_Silk_burg_modified+0xb10>
mov    %r9,%r12
mov    0x58(%rsp),%r14
cmp    $0x4,%r14
setb   %al
neg    %esi
mov    0xd8(%rsp),%ecx
shl    %cl,%esi
neg    %edi
shl    %cl,%edi
mov    %esi,%r10d
sar    $0x10,%r10d
movzwl %si,%r9d
mov    %edi,%r8d
sar    $0x10,%r8d
movzwl %di,%r11d
or     0xf(%rsp),%al
je     1d80 <SKP_Silk_burg_modified+0xc20>
xor    %eax,%eax
movabs $0x100000000,%rsi
mov    0x60(%rsp),%r13
mov    0x168(%rsp),%r15
mov    0x38(%rsp),%rbp
jmp    1ef2 <SKP_Silk_burg_modified+0xd92>
nopw   0x0(%rax,%rax,1)
movd   %r10d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   %r9d,%xmm1
pshufd $0x0,%xmm1,%xmm1
movd   %r8d,%xmm2
pshufd $0x0,%xmm2,%xmm2
movd   %r11d,%xmm3
pshufd $0x0,%xmm3,%xmm3
mov    0xc0(%rsp),%rbx
mov    0x158(%rsp),%rax
xor    %edx,%edx
movabs $0x400000000,%r15
movabs $0x100000000,%rsi
mov    0x60(%rsp),%r13
mov    0x160(%rsp),%rcx
mov    0x38(%rsp),%rbp
movq   (%rax),%xmm4
pshufd $0xc4,%xmm4,%xmm4
pshuflw $0xac,%xmm4,%xmm4
pshufhw $0x24,%xmm4,%xmm4
psrad  $0x10,%xmm4
movdqa %xmm0,%xmm5
pmuludq %xmm4,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm0,%xmm6
pshufd $0xf5,%xmm4,%xmm7
pmuludq %xmm7,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm5
pmuludq %xmm1,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm1,%xmm6
pmuludq %xmm7,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm4
psrad  $0x10,%xmm4
paddd  0x1c0(%rsp,%rdx,4),%xmm5
paddd  %xmm4,%xmm5
movdqa %xmm5,0x1c0(%rsp,%rdx,4)
mov    %rbx,%rdi
sar    $0x1f,%rdi
movq   0x0(%rbp,%rdi,1),%xmm4
punpcklwd %xmm4,%xmm4
psrad  $0x10,%xmm4
movdqa %xmm2,%xmm5
pmuludq %xmm4,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm4,%xmm6
pshufd $0xf5,%xmm2,%xmm7
pmuludq %xmm6,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm5
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm3,%xmm7
pmuludq %xmm6,%xmm7
pshufd $0xe8,%xmm7,%xmm6
punpckldq %xmm6,%xmm4
psrad  $0x10,%xmm4
paddd  0x330(%rsp,%rdx,4),%xmm5
paddd  %xmm4,%xmm5
movdqa %xmm5,0x330(%rsp,%rdx,4)
add    $0x4,%rdx
add    $0xfffffffffffffff8,%rax
add    %r15,%rbx
cmp    %rdx,%rcx
jne    1de0 <SKP_Silk_burg_modified+0xc80>
mov    0x2d8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rcx,%r14
mov    0x168(%rsp),%r15
je     1670 <SKP_Silk_burg_modified+0x510>
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rax,1),%edx
shl    $0x20,%rdx
mov    %r15,%rbx
sub    %rax,%rbx
sub    %rax,%rbx
nopw   0x0(%rax,%rax,1)
movswl (%rbx),%edi
mov    %r10d,%ecx
imul   %edi,%ecx
imul   %r9d,%edi
add    0x1c0(%rsp,%rax,4),%ecx
sar    $0x10,%edi
add    %edi,%ecx
mov    %ecx,0x1c0(%rsp,%rax,4)
mov    %rdx,%rcx
sar    $0x1f,%rcx
movswl 0x0(%rbp,%rcx,1),%ecx
mov    %r8d,%edi
imul   %ecx,%edi
imul   %r11d,%ecx
sar    $0x10,%ecx
add    0x330(%rsp,%rax,4),%edi
add    %ecx,%edi
mov    %edi,0x330(%rsp,%rax,4)
add    $0x1,%rax
add    %rsi,%rdx
add    $0xfffffffffffffffe,%rbx
cmp    %rax,%r14
jne    1f10 <SKP_Silk_burg_modified+0xdb0>
jmp    1670 <SKP_Silk_burg_modified+0x510>
xchg   %ax,%ax
test   %ecx,%ecx
jle    2790 <SKP_Silk_burg_modified+0x1630>
mov    %esi,%ecx
neg    %ecx
mov    %ecx,0x290(%rsp)
mov    0x90(%rsp),%r11
sub    %r13,%r11
not    %esi
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
lea    -0x4(%rdx),%rcx
and    %r13,%rcx
mov    %rcx,0x260(%rsp)
lea    (%rax,%r13,1),%ecx
cmp    %eax,%ecx
setl   %al
mov    %r13,%rcx
shr    $0x20,%rcx
setne  %cl
or     %al,%cl
mov    %cl,0x38(%rsp)
mov    0x58(%rsp),%rax
and    %rdx,%rax
mov    %rax,0x270(%rsp)
mov    %esi,0x180(%rsp)
movd   %esi,%xmm13
mov    0xa0(%rsp),%rax
mov    %rax,0x1b0(%rsp)
mov    0xa8(%rsp),%rax
mov    %rax,0x1a0(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0x190(%rsp)
mov    0xb8(%rsp),%rdx
xor    %edi,%edi
mov    %r11,0x280(%rsp)
movdqa %xmm13,0x250(%rsp)
jmp    208d <SKP_Silk_burg_modified+0xf2d>
nopl   0x0(%rax)
mov    0x2a0(%rsp),%rdi
add    $0x1,%rdi
mov    0x170(%rsp),%rax
mov    0x80(%rsp),%rdx
add    %rax,%rdx
add    %rax,0x190(%rsp)
add    %rax,0x1a0(%rsp)
add    %rax,0x1b0(%rsp)
cmp    0x178(%rsp),%rdi
mov    %r15,%r14
mov    0x60(%rsp),%r13
mov    0x160(%rsp),%r15
mov    0x280(%rsp),%r11
je     2790 <SKP_Silk_burg_modified+0x1630>
mov    %rdi,%rax
imul   0x90(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,2),%r8
movswl (%r8,%r13,2),%esi
mov    %esi,%r9d
mov    0x290(%rsp),%ecx
shl    %cl,%r9d
movswl -0x2(%r8,%r11,2),%r10d
mov    %r10d,%r12d
shl    %cl,%r12d
shl    $0x11,%esi
shl    $0x11,%r10d
test   %r13,%r13
mov    %rdx,0x80(%rsp)
mov    %rdi,0x2a0(%rsp)
je     2436 <SKP_Silk_burg_modified+0x12d6>
cmp    $0x8,%r13
jae    20f0 <SKP_Silk_burg_modified+0xf90>
xor    %eax,%eax
jmp    23be <SKP_Silk_burg_modified+0x125e>
nopl   (%rax)
movd   %r10d,%xmm2
movd   %esi,%xmm13
movd   %r9d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x70(%rsp)
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x40(%rsp)
pxor   %xmm12,%xmm12
xor    %eax,%eax
mov    %rdx,%rcx
xor    %edx,%edx
pxor   %xmm14,%xmm14
movabs $0x800000000,%rdi
mov    0x148(%rsp),%rbp
nopl   (%rax)
movdqa %xmm2,0x20(%rsp)
movdqa 0xe0(%rsp,%rdx,4),%xmm1
movdqa 0xf0(%rsp,%rdx,4),%xmm2
movq   (%rcx),%xmm0
movq   -0x8(%rcx),%xmm3
pshufd $0xc4,%xmm0,%xmm0
pshuflw $0xac,%xmm0,%xmm0
pshufhw $0x24,%xmm0,%xmm0
psrad  $0x10,%xmm0
pshufd $0xc4,%xmm3,%xmm3
pshuflw $0xac,%xmm3,%xmm3
pshufhw $0x24,%xmm3,%xmm7
psrad  $0x10,%xmm7
movdqa 0x70(%rsp),%xmm4
movdqa %xmm4,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshufd $0xf5,%xmm4,%xmm6
pshufd $0xf5,%xmm0,%xmm10
movdqa %xmm6,%xmm5
pmuludq %xmm10,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm3
psubd  %xmm3,%xmm1
movdqa %xmm4,%xmm3
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshufd $0xf5,%xmm7,%xmm5
pmuludq %xmm5,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm3
psubd  %xmm3,%xmm2
movdqa %xmm1,0xe0(%rsp,%rdx,4)
movdqa %xmm2,0xf0(%rsp,%rdx,4)
movdqa 0x210(%rsp,%rdx,4),%xmm3
mov    %rax,%rsi
sar    $0x20,%rsi
add    %r11,%rsi
movq   (%r8,%rsi,2),%xmm1
punpcklwd %xmm1,%xmm2
movq   0x8(%r8,%rsi,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm2
psrad  $0x10,%xmm1
movdqa 0x40(%rsp),%xmm11
movdqa %xmm11,%xmm6
pmuludq %xmm2,%xmm6
pshufd $0xe8,%xmm6,%xmm6
pshufd $0xf5,%xmm2,%xmm15
pshufd $0xf5,%xmm11,%xmm9
movdqa %xmm9,%xmm8
pmuludq %xmm15,%xmm8
pshufd $0xe8,%xmm8,%xmm4
punpckldq %xmm4,%xmm6
psubd  %xmm6,%xmm3
pmuludq %xmm1,%xmm11
pshufd $0xe8,%xmm11,%xmm4
pshufd $0xf5,%xmm1,%xmm8
pmuludq %xmm8,%xmm9
pshufd $0xe8,%xmm9,%xmm6
punpckldq %xmm6,%xmm4
movdqa 0x220(%rsp,%rdx,4),%xmm6
psubd  %xmm4,%xmm6
movdqa %xmm3,0x210(%rsp,%rdx,4)
movdqa %xmm6,0x220(%rsp,%rdx,4)
movdqa 0x2f0(%rsp,%rdx,4),%xmm3
psrad  $0x6,%xmm3
pcmpeqd %xmm9,%xmm9
psubd  %xmm9,%xmm3
psrad  $0x1,%xmm3
pmuludq %xmm3,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm4,%xmm10
pshufd $0xe8,%xmm10,%xmm6
punpckldq %xmm6,%xmm0
movdqa 0x300(%rsp,%rdx,4),%xmm6
psrad  $0x6,%xmm6
psubd  %xmm9,%xmm6
psrad  $0x1,%xmm6
paddd  %xmm0,%xmm13
pmuludq %xmm6,%xmm7
pshufd $0xe8,%xmm7,%xmm0
pshufd $0xf5,%xmm6,%xmm7
pmuludq %xmm7,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm0
paddd  %xmm0,%xmm14
pmuludq %xmm2,%xmm3
pmuludq %xmm15,%xmm4
pshufd $0xe8,%xmm3,%xmm0
pshufd $0xe8,%xmm4,%xmm2
punpckldq %xmm2,%xmm0
movdqa 0x20(%rsp),%xmm2
paddd  %xmm0,%xmm2
pmuludq %xmm1,%xmm6
pmuludq %xmm8,%xmm7
pshufd $0xe8,%xmm6,%xmm0
pshufd $0xe8,%xmm7,%xmm1
punpckldq %xmm1,%xmm0
paddd  %xmm0,%xmm12
add    $0x8,%rdx
add    $0xfffffffffffffff0,%rcx
add    %rdi,%rax
cmp    %rdx,%rbp
jne    2140 <SKP_Silk_burg_modified+0xfe0>
paddd  %xmm13,%xmm14
pshufd $0xee,%xmm14,%xmm0
paddd  %xmm14,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
paddd  %xmm2,%xmm12
pshufd $0xee,%xmm12,%xmm0
paddd  %xmm12,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%r10d
mov    0x260(%rsp),%rcx
mov    %rcx,%rax
cmp    %rcx,%r13
pcmpeqd %xmm12,%xmm12
movdqa 0x250(%rsp),%xmm13
je     2436 <SKP_Silk_burg_modified+0x12d6>
mov    %rax,%rcx
shl    $0x20,%rcx
mov    0x190(%rsp),%rdx
sub    %rax,%rdx
sub    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movswl (%rdx),%edi
mov    %r9d,%ebx
imul   %edi,%ebx
sub    %ebx,0xe0(%rsp,%rax,4)
mov    %rcx,%rbx
sar    $0x20,%rbx
add    %r11,%rbx
movswl (%r8,%rbx,2),%ebx
mov    %r12d,%ebp
imul   %ebx,%ebp
sub    %ebp,0x210(%rsp,%rax,4)
mov    0x2f0(%rsp,%rax,4),%ebp
sar    $0x6,%ebp
add    $0x1,%ebp
sar    %ebp
imul   %ebp,%edi
add    %edi,%esi
imul   %ebx,%ebp
add    %ebp,%r10d
add    $0x1,%rax
add    %r14,%rcx
add    $0xfffffffffffffffe,%rdx
cmp    %rax,%r13
jne    23e0 <SKP_Silk_burg_modified+0x1280>
mov    0x58(%rsp),%rbp
cmp    $0x4,%rbp
setb   %cl
neg    %esi
neg    %r10d
mov    %esi,%r13d
sar    $0x10,%r13d
movzwl %si,%r12d
mov    %r10d,%edx
sar    $0x10,%edx
movzwl %r10w,%r11d
or     0x38(%rsp),%cl
mov    %r12d,0x20(%rsp)
je     2490 <SKP_Silk_burg_modified+0x1330>
xor    %edi,%edi
movabs $0x100000000,%r15
mov    0x180(%rsp),%r9d
mov    %r8,%r14
mov    %edx,%r8d
jmp    26c9 <SKP_Silk_burg_modified+0x1569>
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,0x40(%rsp)
movd   %r13d,%xmm0
pshufd $0x0,%xmm0,%xmm9
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm8
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm10
mov    %edx,0x1c(%rsp)
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm11
mov    %r11d,0x70(%rsp)
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm5
movd   %r10d,%xmm0
pshufd $0x0,%xmm0,%xmm6
mov    0xc0(%rsp),%rcx
mov    0x1a0(%rsp),%rdi
xor    %ebx,%ebx
movabs $0x400000000,%rax
nopl   0x0(%rax,%rax,1)
movq   (%rdi),%xmm0
pshufd $0xc4,%xmm0,%xmm0
pshuflw $0xac,%xmm0,%xmm0
pshufhw $0x24,%xmm0,%xmm2
psrad  $0x10,%xmm2
pxor   %xmm0,%xmm0
movss  %xmm13,%xmm0
pslld  %xmm0,%xmm2
movdqa %xmm2,%xmm7
pslld  $0x10,%xmm7
psrad  $0x10,%xmm7
movdqa %xmm7,%xmm1
pmuludq %xmm9,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm7,%xmm3
pshufd $0xf5,%xmm9,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm1
pmuludq %xmm8,%xmm7
pshufd $0xe8,%xmm7,%xmm4
pshufd $0xf5,%xmm8,%xmm7
pmuludq %xmm3,%xmm7
pshufd $0xe8,%xmm7,%xmm3
punpckldq %xmm3,%xmm4
psrad  $0x10,%xmm4
psrad  $0xf,%xmm2
psubd  %xmm12,%xmm2
psrad  $0x1,%xmm2
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm10,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm10,%xmm7
pmuludq %xmm3,%xmm7
pshufd $0xe8,%xmm7,%xmm3
punpckldq %xmm3,%xmm2
paddd  %xmm4,%xmm2
paddd  0x1c0(%rsp,%rbx,4),%xmm1
paddd  %xmm2,%xmm1
movdqa %xmm1,0x1c0(%rsp,%rbx,4)
mov    %rcx,%rdx
sar    $0x1f,%rdx
movq   (%r8,%rdx,1),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm1
pslld  %xmm0,%xmm1
movdqa %xmm1,%xmm2
pslld  $0x10,%xmm2
psrad  $0x10,%xmm2
movdqa %xmm2,%xmm0
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm2,%xmm3
pshufd $0xf5,%xmm11,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm0
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm5,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm3
punpckldq %xmm3,%xmm2
psrad  $0x10,%xmm2
psrad  $0xf,%xmm1
psubd  %xmm12,%xmm1
psrad  $0x1,%xmm1
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm6,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm3
punpckldq %xmm3,%xmm1
paddd  %xmm2,%xmm1
paddd  0x330(%rsp,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqa %xmm0,0x330(%rsp,%rbx,4)
add    $0x4,%rbx
add    $0xfffffffffffffff8,%rdi
add    %rax,%rcx
cmp    %rbx,%r15
jne    2500 <SKP_Silk_burg_modified+0x13a0>
mov    0x270(%rsp),%rax
mov    %rax,%rdi
cmp    %rax,%rbp
movabs $0x100000000,%r15
mov    0x180(%rsp),%r9d
mov    0x70(%rsp),%r11d
mov    0x40(%rsp),%r13d
mov    %r8,%r14
mov    0x1c(%rsp),%r8d
je     2030 <SKP_Silk_burg_modified+0xed0>
mov    0xc8(%rsp),%rax
lea    (%rax,%rdi,1),%ebx
shl    $0x20,%rbx
mov    0x1b0(%rsp),%rdx
sub    %rdi,%rdx
sub    %rdi,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,%r12
movswl (%rdx),%ebp
mov    %r9d,%ecx
shl    %cl,%ebp
movswl %bp,%eax
mov    %eax,%ecx
imul   %r13d,%ecx
imul   0x20(%rsp),%eax
sar    $0x10,%eax
sar    $0xf,%ebp
add    $0x1,%ebp
sar    %ebp
imul   %esi,%ebp
add    0x1c0(%rsp,%rdi,4),%ecx
add    %eax,%ecx
add    %ebp,%ecx
mov    %ecx,0x1c0(%rsp,%rdi,4)
mov    %rbx,%rax
sar    $0x1f,%rax
movswl (%r14,%rax,1),%eax
mov    %r9d,%ecx
shl    %cl,%eax
movswl %ax,%ecx
mov    %ecx,%ebp
imul   %r8d,%ebp
imul   %r11d,%ecx
add    0x330(%rsp,%rdi,4),%ebp
sar    $0x10,%ecx
add    %ecx,%ebp
sar    $0xf,%eax
add    $0x1,%eax
sar    %eax
imul   %r10d,%eax
add    %eax,%ebp
mov    %ebp,0x330(%rsp,%rdi,4)
mov    %r12,%rbp
add    $0x1,%rdi
add    %r15,%rbx
add    $0xfffffffffffffffe,%rdx
cmp    %rdi,%r12
jne    26f0 <SKP_Silk_burg_modified+0x1590>
jmp    2030 <SKP_Silk_burg_modified+0xed0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xe0(%rsp,%r13,4),%ebp
mov    0x210(%rsp,%r13,4),%r12d
mov    0x1c0(%rsp),%esi
add    0x330(%rsp),%esi
xor    %r15d,%r15d
test   %r13,%r13
je     2880 <SKP_Silk_burg_modified+0x1720>
mov    $0x4,%ebx
jmp    284a <SKP_Silk_burg_modified+0x16ea>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rax),%ecx
shl    %cl,%r14d
movslq 0x20c(%rsp,%r13,4),%rsi
movslq %r14d,%rdx
imul   %rdx,%rsi
shr    $0x20,%rsi
mov    $0x9,%cl
sub    %al,%cl
shl    %cl,%esi
movslq 0xdc(%rsp,%r13,4),%rax
imul   %rdx,%rax
shr    $0x20,%rax
shl    %cl,%eax
add    %esi,%ebp
add    %eax,%r12d
movslq 0x330(%rsp,%rbx,1),%rax
movslq 0x1c0(%rsp,%rbx,1),%rsi
add    %rax,%rsi
movslq 0x330(%rsp,%r13,4),%rax
imul   %rdx,%rax
shr    $0x20,%rax
shl    %cl,%eax
imul   %rdx,%rsi
shr    $0x20,%rsi
shl    %cl,%esi
add    %eax,%r15d
mov    0x20(%rsp),%eax
add    %esi,%eax
mov    %eax,%esi
add    $0x4,%rbx
add    $0xffffffffffffffff,%r13
je     2880 <SKP_Silk_burg_modified+0x1720>
mov    %esi,0x20(%rsp)
mov    0x2ec(%rsp,%rbx,1),%r14d
mov    %r14d,%edi
neg    %edi
cmovs  %r14d,%edi
xor    %eax,%eax
call   1030 <SKP_Silk_CLZ32@plt>
cmp    $0x9,%eax
jl     27d0 <SKP_Silk_burg_modified+0x1670>
mov    $0x9,%eax
jmp    27d0 <SKP_Silk_burg_modified+0x1670>
nopl   0x0(%rax)
mov    0x60(%rsp),%r13
mov    %ebp,0x1c4(%rsp,%r13,4)
mov    %r12d,0x334(%rsp,%r13,4)
add    %r12d,%r15d
add    %r15d,%r15d
neg    %r15d
mov    %r15d,%eax
neg    %eax
cmovs  %r15d,%eax
cmp    %esi,%eax
jge    2bfa <SKP_Silk_burg_modified+0x1a9a>
lea    0x1(%r13),%r12
mov    %r15d,%edi
mov    $0x1f,%edx
xor    %eax,%eax
call   1060 <SKP_DIV32_varQ@plt>
test   %r13,%r13
je     2970 <SKP_Silk_burg_modified+0x1810>
mov    %r12d,%r8d
shr    %r8d
movslq %eax,%rcx
mov    0x128(%rsp),%r10
mov    %r10,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq 0x2f0(%rsp,%rdi,4),%rbp
movslq 0x2f0(%rsp,%rsi,4),%rdx
mov    %rdx,%rbx
imul   %rcx,%rbx
shr    $0x1f,%rbx
and    $0xfffffffe,%ebx
add    %ebp,%ebx
mov    %ebx,0x2f0(%rsp,%rdi,4)
imul   %rcx,%rbp
shr    $0x1f,%rbp
and    $0xfffffffe,%ebp
add    %edx,%ebp
mov    %ebp,0x2f0(%rsp,%rsi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
cmp    %r8,%rdi
jb     28f0 <SKP_Silk_burg_modified+0x1790>
mov    0x98(%rsp),%r14
mov    0x140(%rsp),%rbx
movaps 0x6c0(%rip),%xmm10
pcmpeqd %xmm12,%xmm12
mov    0x138(%rsp),%r8
mov    0x130(%rsp),%r9
jmp    29a8 <SKP_Silk_burg_modified+0x1848>
nopw   0x0(%rax,%rax,1)
movslq %eax,%rcx
mov    0x98(%rsp),%r14
mov    0x140(%rsp),%rbx
movaps 0x685(%rip),%xmm10
pcmpeqd %xmm12,%xmm12
mov    0x138(%rsp),%r8
mov    0x130(%rsp),%r9
mov    0x128(%rsp),%r10
sar    $0x7,%eax
mov    %eax,0x2f0(%rsp,%r13,4)
cmp    $0x4,%r9
jae    29c0 <SKP_Silk_burg_modified+0x1860>
xor    %eax,%eax
jmp    2b1d <SKP_Silk_burg_modified+0x19bd>
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
neg    %rdx
mov    %r9,%rax
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
and    %rsi,%rax
movq   %rcx,%xmm0
pshufd $0x44,%xmm0,%xmm2
xor    %esi,%esi
lea    0x1c0(%rsp),%rdi
xchg   %ax,%ax
movdqa (%rdi),%xmm1
movdqu (%rbx,%rsi,4),%xmm3
pshufd $0x1b,%xmm3,%xmm8
pshufd $0x11,%xmm3,%xmm4
pxor   %xmm5,%xmm5
pcmpgtd %xmm4,%xmm5
punpckldq %xmm5,%xmm4
pxor   %xmm6,%xmm6
pcmpgtd %xmm8,%xmm6
movdqa %xmm8,%xmm7
punpckldq %xmm6,%xmm7
movdqa %xmm2,%xmm0
pmuludq %xmm7,%xmm0
movdqa %xmm2,%xmm3
psrlq  $0x20,%xmm3
pmuludq %xmm3,%xmm7
pshufd $0xd4,%xmm6,%xmm6
pmuludq %xmm2,%xmm6
paddq  %xmm7,%xmm6
psllq  $0x20,%xmm6
paddq  %xmm0,%xmm6
movdqa %xmm2,%xmm0
pmuludq %xmm4,%xmm0
pmuludq %xmm3,%xmm4
pshufd $0xd4,%xmm5,%xmm5
pmuludq %xmm2,%xmm5
paddq  %xmm4,%xmm5
psllq  $0x20,%xmm5
paddq  %xmm0,%xmm5
psrlq  $0x1f,%xmm5
psrlq  $0x1f,%xmm6
shufps $0x88,%xmm5,%xmm6
andps  %xmm10,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm6,(%rdi)
pxor   %xmm0,%xmm0
pcmpgtd %xmm1,%xmm0
pshufd $0xee,%xmm1,%xmm4
punpckldq %xmm0,%xmm1
pxor   %xmm5,%xmm5
pcmpgtd %xmm4,%xmm5
punpckldq %xmm5,%xmm4
movdqa %xmm3,%xmm6
pmuludq %xmm4,%xmm6
pshufd $0xd4,%xmm5,%xmm5
pmuludq %xmm2,%xmm5
paddq  %xmm6,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm2,%xmm4
paddq  %xmm5,%xmm4
pmuludq %xmm1,%xmm3
pshufd $0xd4,%xmm0,%xmm0
pmuludq %xmm2,%xmm0
paddq  %xmm3,%xmm0
psllq  $0x20,%xmm0
pmuludq %xmm2,%xmm1
paddq  %xmm0,%xmm1
psrlq  $0x1f,%xmm1
psrlq  $0x1f,%xmm4
shufps $0x88,%xmm4,%xmm1
andps  %xmm10,%xmm1
paddd  %xmm8,%xmm1
pshufd $0x1b,%xmm1,%xmm0
movdqu %xmm0,(%rbx,%rsi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rdx
jne    29f0 <SKP_Silk_burg_modified+0x1890>
cmp    %rax,%r9
je     2b6e <SKP_Silk_burg_modified+0x1a0e>
lea    0x0(,%rax,4),%rsi
mov    %r8,%rdx
sub    %rsi,%rdx
nopl   0x0(%rax,%rax,1)
movslq 0x1c0(%rsp,%rax,4),%rsi
movslq (%rdx),%rbp
mov    %rbp,%rdi
imul   %rcx,%rdi
shr    $0x1f,%rdi
and    $0xfffffffe,%edi
add    %esi,%edi
mov    %edi,0x1c0(%rsp,%rax,4)
imul   %rcx,%rsi
shr    $0x1f,%rsi
and    $0xfffffffe,%esi
add    %ebp,%esi
mov    %esi,(%rdx)
add    $0x1,%rax
add    $0xfffffffffffffffc,%rdx
cmp    %rax,%r9
jne    2b30 <SKP_Silk_burg_modified+0x19d0>
cmp    %r14,%r12
je     2c28 <SKP_Silk_burg_modified+0x1ac8>
add    $0x1,%r9
mov    0x58(%rsp),%rdx
add    $0x1,%rdx
mov    0x4(%rsp),%esi
addq   $0x2,0xb8(%rsp)
addq   $0x2,0xb0(%rsp)
addq   $0x2,0xa8(%rsp)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0xc0(%rsp)
addq   $0xffffffffffffffff,0xc8(%rsp)
addq   $0x2,0xa0(%rsp)
add    $0x1,%r10
add    $0x4,%rbx
add    $0x4,%r8
mov    %r12,%r13
mov    0x6c(%rsp),%ecx
movabs $0x100000000,%r14
jmp    1570 <SKP_Silk_burg_modified+0x410>
mov    $0x10000,%edx
mov    0x1c0(%rsp),%ecx
jmp    2eb3 <SKP_Silk_burg_modified+0x1d53>
mov    %r13d,%eax
lea    (%rsp,%rax,4),%rdi
add    $0x2f0,%rdi
mov    0x3d8(%rsp),%eax
sub    %r13d,%eax
movslq %eax,%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x98(%rsp),%r14
mov    0x1c0(%rsp),%ecx
mov    0x3d8(%rsp),%eax
test   %eax,%eax
jle    2c54 <SKP_Silk_burg_modified+0x1af4>
cmp    $0x4,%eax
jae    2c5e <SKP_Silk_burg_modified+0x1afe>
mov    $0x10000,%edx
xor    %r8d,%r8d
mov    0x120(%rsp),%r11
jmp    2e37 <SKP_Silk_burg_modified+0x1cd7>
mov    $0x10000,%edx
jmp    2eb3 <SKP_Silk_burg_modified+0x1d53>
mov    %r14d,%r8d
and    $0xfffffffc,%r8d
movd   %ecx,%xmm1
lea    0x0(,%r14,4),%rcx
and    $0xfffffffffffffff0,%rcx
movdqa 0x3a3(%rip),%xmm0
xor    %edx,%edx
mov    0x120(%rsp),%r11
movdqa 0x370(%rip),%xmm9
movdqa 0x2f0(%rsp,%rdx,1),%xmm3
psrad  $0x7,%xmm3
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm3
movdqa %xmm3,%xmm7
psrad  $0x1,%xmm7
movdqu 0x1c4(%rsp,%rdx,1),%xmm10
movdqa %xmm3,%xmm6
psrad  $0x10,%xmm6
psubd  %xmm2,%xmm6
psrad  $0x1,%xmm6
movdqa %xmm6,%xmm11
pshufd $0xf5,%xmm6,%xmm2
movdqa %xmm2,0x20(%rsp)
movdqa %xmm7,%xmm13
pmuludq %xmm7,%xmm6
pshufd $0xf5,%xmm7,%xmm12
pxor   %xmm14,%xmm14
psubd  %xmm7,%xmm14
pslld  $0x10,%xmm7
psrad  $0x10,%xmm7
movdqa %xmm10,%xmm4
pmuludq %xmm10,%xmm11
pshufd $0xf5,%xmm10,%xmm15
psrad  $0x10,%xmm10
packssdw %xmm10,%xmm10
movdqa %xmm7,%xmm2
packssdw %xmm2,%xmm2
movdqa %xmm2,%xmm5
pmulhw %xmm10,%xmm5
pmullw %xmm2,%xmm10
punpcklwd %xmm5,%xmm10
paddd  %xmm1,%xmm10
pand   %xmm9,%xmm4
movdqa %xmm7,%xmm1
pmuludq %xmm4,%xmm1
pshufd $0xe8,%xmm1,%xmm5
pshufd $0xf5,%xmm4,%xmm1
pshufd $0xf5,%xmm7,%xmm8
pmuludq %xmm8,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm5
pshufd $0xe8,%xmm11,%xmm1
movdqa 0x20(%rsp),%xmm11
pmuludq %xmm11,%xmm15
pshufd $0xe8,%xmm15,%xmm4
punpckldq %xmm4,%xmm1
paddd  %xmm10,%xmm1
psrad  $0x10,%xmm5
paddd  %xmm5,%xmm1
psrad  $0x11,%xmm3
packssdw %xmm3,%xmm3
movdqa %xmm2,%xmm4
pmulhw %xmm3,%xmm4
pmullw %xmm2,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm0,%xmm3
pand   %xmm9,%xmm13
pmuludq %xmm13,%xmm7
pshufd $0xe8,%xmm7,%xmm2
pshufd $0xf5,%xmm13,%xmm0
pmuludq %xmm8,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
psrad  $0x10,%xmm2
pshufd $0xe8,%xmm6,%xmm0
pmuludq %xmm11,%xmm12
pshufd $0xe8,%xmm12,%xmm4
punpckldq %xmm4,%xmm0
paddd  %xmm3,%xmm0
paddd  %xmm2,%xmm0
movdqu %xmm14,(%r11,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    2c90 <SKP_Silk_burg_modified+0x1b30>
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%ecx
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %r14,%r8
je     2eb3 <SKP_Silk_burg_modified+0x1d53>
mov    %edx,%r9d
mov    %ecx,%r10d
nopl   (%rax)
mov    0x2f0(%rsp,%r8,4),%edi
sar    $0x7,%edi
add    $0x1,%edi
mov    %edi,%esi
sar    %esi
mov    0x1c4(%rsp,%r8,4),%ecx
mov    %ecx,%eax
movswl %si,%ebx
movzwl %cx,%ebp
mov    %edi,%edx
sar    $0x10,%edx
add    $0x1,%edx
sar    %edx
imul   %edx,%ecx
imul   %esi,%edx
neg    %esi
mov    %esi,(%r11,%r8,4)
lea    0x1(%r8),%rsi
sar    $0x10,%eax
imul   %ebx,%eax
add    %r10d,%eax
imul   %ebx,%ebp
sar    $0x10,%ebp
add    %eax,%ecx
add    %ebp,%ecx
sar    $0x11,%edi
imul   %ebx,%edi
add    %r9d,%edi
movzwl %bx,%eax
imul   %ebx,%eax
sar    $0x10,%eax
add    %edi,%edx
add    %eax,%edx
mov    %rsi,%r8
mov    %edx,%r9d
mov    %ecx,%r10d
cmp    %rsi,%r14
jne    2e40 <SKP_Silk_burg_modified+0x1ce0>
movslq 0x8(%rsp),%rax
imul   0x2b8(%rsp),%rax
mov    %rax,%rsi
shr    $0x20,%rsi
sar    $0x30,%rax
neg    %edx
movswl %dx,%edi
imul   %edi,%eax
movzwl %si,%ebp
imul   %edi,%ebp
sar    $0x10,%ebp
sar    $0xf,%edx
add    $0x1,%edx
sar    %edx
imul   %esi,%edx
add    %ecx,%edx
add    %eax,%edx
add    %ebp,%edx
mov    0x2c0(%rsp),%rax
mov    %edx,(%rax)
xor    %eax,%eax
sub    0x4(%rsp),%eax
mov    0x2c8(%rsp),%rcx
mov    %eax,(%rcx)
add    $0x398,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @SKP_Silk_burg_modified(i32* %0, i32* %1, i32* %2, i16* %3, i32 %4, i32 %5, i32 %6, i32 %7) {
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i16*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i16*
%34 = alloca [16 x i32]
%35 = alloca [16 x i32]
%36 = alloca [16 x i32]
%37 = alloca [17 x i32]
%38 = alloca [17 x i32]
store i32* %0, i32** %9
store i32* %1, i32** %10
store i32* %2, i32** %11
store i16* %3, i16** %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store i32 %6, i32* %15
store i32 %7, i32* %16
%39 = load i16*, i16** %12
%40 = load i32, i32* %14
%41 = load i32, i32* %13
%42 = mul nsw i32 %40, %41
%43 = call i32 (i32*, i32*, i16*, i32, ...) bitcast (i32 (...)* @SKP_Silk_sum_sqr_shift to i32 (i32*, i32*, i16*, i32, ...)*)(i32* %23, i32* %21, i16* %39, i32 %42)
%44 = load i32, i32* %21
%45 = icmp sgt i32 %44, 8
br i1 %45, label %46, label %51
46: ; preds = %8
%47 = load i32, i32* %23
%48 = load i32, i32* %21
%49 = sub nsw i32 %48, 8
%50 = shl i32 %47, %49
store i32 %50, i32* %23
store i32 8, i32* %21
br label %94
51: ; preds = %8
%52 = load i32, i32* %23
%53 = call i32 (i32, ...) bitcast (i32 (...)* @SKP_Silk_CLZ32 to i32 (i32, ...)*)(i32 %52)
%54 = sub nsw i32 %53, 1
store i32 %54, i32* %20
%55 = load i32, i32* %20
%56 = sub nsw i32 2, %55
store i32 %56, i32* %22
%57 = load i32, i32* %22
%58 = icmp sgt i32 %57, 0
br i1 %58, label %59, label %74
59: ; preds = %51
%60 = load i32, i32* %22
%61 = load i32, i32* %21
%62 = sub nsw i32 8, %61
%63 = icmp slt i32 %60, %62
br i1 %63, label %64, label %66
64: ; preds = %59
%65 = load i32, i32* %22
br label %69
66: ; preds = %59
%67 = load i32, i32* %21
%68 = sub nsw i32 8, %67
br label %69
69: ; preds = %66, %64
%70 = phi i32 [ %65, %64 ], [ %68, %66 ]
store i32 %70, i32* %22
%71 = load i32, i32* %23
%72 = load i32, i32* %22
%73 = ashr i32 %71, %72
store i32 %73, i32* %23
br label %90
74: ; preds = %51
%75 = load i32, i32* %22
%76 = load i32, i32* %21
%77 = sub nsw i32 -16, %76
%78 = icmp sgt i32 %75, %77
br i1 %78, label %79, label %81
79: ; preds = %74
%80 = load i32, i32* %22
br label %84
81: ; preds = %74
%82 = load i32, i32* %21
%83 = sub nsw i32 -16, %82
br label %84
84: ; preds = %81, %79
%85 = phi i32 [ %80, %79 ], [ %83, %81 ]
store i32 %85, i32* %22
%86 = load i32, i32* %23
%87 = load i32, i32* %22
%88 = sub nsw i32 0, %87
%89 = shl i32 %86, %88
store i32 %89, i32* %23
br label %90
90: ; preds = %84, %69
%91 = load i32, i32* %22
%92 = load i32, i32* %21
%93 = add nsw i32 %92, %91
store i32 %93, i32* %21
br label %94
94: ; preds = %90, %46
%95 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 0
%96 = bitcast i32* %95 to i8*
%97 = load i32, i32* %21
%98 = icmp sgt i32 %97, 0
br i1 %98, label %99, label %142
99: ; preds = %94
store i32 0, i32* %19
br label %100
100: ; preds = %138, %99
%101 = load i32, i32* %19
%102 = load i32, i32* %14
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %141
104: ; preds = %100
%105 = load i16*, i16** %12
%106 = load i32, i32* %19
%107 = load i32, i32* %13
%108 = mul nsw i32 %106, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i16, i16* %105, i64 %109
store i16* %110, i16** %33
store i32 1, i32* %18
br label %111
111: ; preds = %134, %104
%112 = load i32, i32* %18
%113 = load i32, i32* %16
%114 = add nsw i32 %113, 1
%115 = icmp slt i32 %112, %114
br i1 %115, label %116, label %137
116: ; preds = %111
%117 = load i16*, i16** %33
%118 = load i16*, i16** %33
%119 = load i32, i32* %18
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i16, i16* %118, i64 %120
%122 = load i32, i32* %13
%123 = load i32, i32* %18
%124 = sub nsw i32 %122, %123
%125 = call i32 (i16*, i16*, i32, ...) bitcast (i32 (...)* @SKP_Silk_inner_prod16_aligned_64 to i32 (i16*, i16*, i32, ...)*)(i16* %117, i16* %121, i32 %124)
%126 = load i32, i32* %21
%127 = ashr i32 %125, %126
%128 = load i32, i32* %18
%129 = sub nsw i32 %128, 1
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %130
%132 = load i32, i32* %131
%133 = add nsw i32 %132, %127
store i32 %133, i32* %131
br label %134
134: ; preds = %116
%135 = load i32, i32* %18
%136 = add nsw i32 %135, 1
store i32 %136, i32* %18
br label %111
137: ; preds = %111
br label %138
138: ; preds = %137
%139 = load i32, i32* %19
%140 = add nsw i32 %139, 1
store i32 %140, i32* %19
br label %100
141: ; preds = %100
br label %186
142: ; preds = %94
store i32 0, i32* %19
br label %143
143: ; preds = %182, %142
%144 = load i32, i32* %19
%145 = load i32, i32* %14
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %185
147: ; preds = %143
%148 = load i16*, i16** %12
%149 = load i32, i32* %19
%150 = load i32, i32* %13
%151 = mul nsw i32 %149, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i16, i16* %148, i64 %152
store i16* %153, i16** %33
store i32 1, i32* %18
br label %154
154: ; preds = %178, %147
%155 = load i32, i32* %18
%156 = load i32, i32* %16
%157 = add nsw i32 %156, 1
%158 = icmp slt i32 %155, %157
br i1 %158, label %159, label %181
159: ; preds = %154
%160 = load i16*, i16** %33
%161 = load i16*, i16** %33
%162 = load i32, i32* %18
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i16, i16* %161, i64 %163
%165 = load i32, i32* %13
%166 = load i32, i32* %18
%167 = sub nsw i32 %165, %166
%168 = call i32 (i16*, i16*, i32, ...) bitcast (i32 (...)* @SKP_Silk_inner_prod_aligned to i32 (i16*, i16*, i32, ...)*)(i16* %160, i16* %164, i32 %167)
%169 = load i32, i32* %21
%170 = sub nsw i32 0, %169
%171 = shl i32 %168, %170
%172 = load i32, i32* %18
%173 = sub nsw i32 %172, 1
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %174
%176 = load i32, i32* %175
%177 = add nsw i32 %176, %171
store i32 %177, i32* %175
br label %178
178: ; preds = %159
%179 = load i32, i32* %18
%180 = add nsw i32 %179, 1
store i32 %180, i32* %18
br label %154
181: ; preds = %154
br label %182
182: ; preds = %181
%183 = load i32, i32* %19
%184 = add nsw i32 %183, 1
store i32 %184, i32* %19
br label %143
185: ; preds = %143
br label %186
186: ; preds = %185, %141
%187 = getelementptr inbounds [16 x i32], [16 x i32]* %35, i64 0, i64 0
%188 = bitcast i32* %187 to i8*
%189 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 0
%190 = bitcast i32* %189 to i8*
%191 = load i32, i32* %23
%192 = load i32, i32* %15
%193 = sext i32 %192 to i64
%194 = load i32, i32* %23
%195 = sext i32 %194 to i64
%196 = mul nsw i64 %193, %195
%197 = ashr i64 %196, 32
%198 = trunc i64 %197 to i32
%199 = add nsw i32 %191, %198
%200 = add nsw i32 %199, 1
%201 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 0
store i32 %200, i32* %201
%202 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 0
store i32 %200, i32* %202
store i32 0, i32* %18
br label %203
203: ; preds = %1051, %186
%204 = load i32, i32* %18
%205 = load i32, i32* %16
%206 = icmp slt i32 %204, %205
br i1 %206, label %207, label %1054
207: ; preds = %203
%208 = load i32, i32* %21
%209 = icmp sgt i32 %208, -2
br i1 %209, label %210, label %496
210: ; preds = %207
store i32 0, i32* %19
br label %211
211: ; preds = %492, %210
%212 = load i32, i32* %19
%213 = load i32, i32* %14
%214 = icmp slt i32 %212, %213
br i1 %214, label %215, label %495
215: ; preds = %211
%216 = load i16*, i16** %12
%217 = load i32, i32* %19
%218 = load i32, i32* %13
%219 = mul nsw i32 %217, %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i16, i16* %216, i64 %220
store i16* %221, i16** %33
%222 = load i16*, i16** %33
%223 = load i32, i32* %18
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i16, i16* %222, i64 %224
%226 = load i16, i16* %225
%227 = sext i16 %226 to i32
%228 = load i32, i32* %21
%229 = sub nsw i32 16, %228
%230 = shl i32 %227, %229
%231 = sub nsw i32 0, %230
store i32 %231, i32* %31
%232 = load i16*, i16** %33
%233 = load i32, i32* %13
%234 = load i32, i32* %18
%235 = sub nsw i32 %233, %234
%236 = sub nsw i32 %235, 1
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i16, i16* %232, i64 %237
%239 = load i16, i16* %238
%240 = sext i16 %239 to i32
%241 = load i32, i32* %21
%242 = sub nsw i32 16, %241
%243 = shl i32 %240, %242
%244 = sub nsw i32 0, %243
store i32 %244, i32* %32
%245 = load i16*, i16** %33
%246 = load i32, i32* %18
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds i16, i16* %245, i64 %247
%249 = load i16, i16* %248
%250 = sext i16 %249 to i32
%251 = shl i32 %250, 8
store i32 %251, i32* %29
%252 = load i16*, i16** %33
%253 = load i32, i32* %13
%254 = load i32, i32* %18
%255 = sub nsw i32 %253, %254
%256 = sub nsw i32 %255, 1
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i16, i16* %252, i64 %257
%259 = load i16, i16* %258
%260 = sext i16 %259 to i32
%261 = shl i32 %260, 8
store i32 %261, i32* %30
store i32 0, i32* %17
br label %262
262: ; preds = %399, %215
%263 = load i32, i32* %17
%264 = load i32, i32* %18
%265 = icmp slt i32 %263, %264
br i1 %265, label %266, label %402
266: ; preds = %262
%267 = load i32, i32* %17
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %268
%270 = load i32, i32* %269
%271 = load i32, i32* %31
%272 = ashr i32 %271, 16
%273 = load i16*, i16** %33
%274 = load i32, i32* %18
%275 = load i32, i32* %17
%276 = sub nsw i32 %274, %275
%277 = sub nsw i32 %276, 1
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i16, i16* %273, i64 %278
%280 = load i16, i16* %279
%281 = sext i16 %280 to i32
%282 = mul nsw i32 %272, %281
%283 = load i32, i32* %31
%284 = and i32 %283, 65535
%285 = load i16*, i16** %33
%286 = load i32, i32* %18
%287 = load i32, i32* %17
%288 = sub nsw i32 %286, %287
%289 = sub nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i16, i16* %285, i64 %290
%292 = load i16, i16* %291
%293 = sext i16 %292 to i32
%294 = mul nsw i32 %284, %293
%295 = ashr i32 %294, 16
%296 = add nsw i32 %282, %295
%297 = add nsw i32 %270, %296
%298 = load i32, i32* %17
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %299
store i32 %297, i32* %300
%301 = load i32, i32* %17
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds [16 x i32], [16 x i32]* %35, i64 0, i64 %302
%304 = load i32, i32* %303
%305 = load i32, i32* %32
%306 = ashr i32 %305, 16
%307 = load i16*, i16** %33
%308 = load i32, i32* %13
%309 = load i32, i32* %18
%310 = sub nsw i32 %308, %309
%311 = load i32, i32* %17
%312 = add nsw i32 %310, %311
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i16, i16* %307, i64 %313
%315 = load i16, i16* %314
%316 = sext i16 %315 to i32
%317 = mul nsw i32 %306, %316
%318 = load i32, i32* %32
%319 = and i32 %318, 65535
%320 = load i16*, i16** %33
%321 = load i32, i32* %13
%322 = load i32, i32* %18
%323 = sub nsw i32 %321, %322
%324 = load i32, i32* %17
%325 = add nsw i32 %323, %324
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i16, i16* %320, i64 %326
%328 = load i16, i16* %327
%329 = sext i16 %328 to i32
%330 = mul nsw i32 %319, %329
%331 = ashr i32 %330, 16
%332 = add nsw i32 %317, %331
%333 = add nsw i32 %304, %332
%334 = load i32, i32* %17
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds [16 x i32], [16 x i32]* %35, i64 0, i64 %335
store i32 %333, i32* %336
%337 = load i32, i32* %17
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %338
%340 = load i32, i32* %339
store i32 %340, i32* %27
%341 = load i32, i32* %29
%342 = load i32, i32* %27
%343 = ashr i32 %342, 16
%344 = load i16*, i16** %33
%345 = load i32, i32* %18
%346 = load i32, i32* %17
%347 = sub nsw i32 %345, %346
%348 = sub nsw i32 %347, 1
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i16, i16* %344, i64 %349
%351 = load i16, i16* %350
%352 = sext i16 %351 to i32
%353 = mul nsw i32 %343, %352
%354 = load i32, i32* %27
%355 = and i32 %354, 65535
%356 = load i16*, i16** %33
%357 = load i32, i32* %18
%358 = load i32, i32* %17
%359 = sub nsw i32 %357, %358
%360 = sub nsw i32 %359, 1
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds i16, i16* %356, i64 %361
%363 = load i16, i16* %362
%364 = sext i16 %363 to i32
%365 = mul nsw i32 %355, %364
%366 = ashr i32 %365, 16
%367 = add nsw i32 %353, %366
%368 = add nsw i32 %341, %367
store i32 %368, i32* %29
%369 = load i32, i32* %30
%370 = load i32, i32* %27
%371 = ashr i32 %370, 16
%372 = load i16*, i16** %33
%373 = load i32, i32* %13
%374 = load i32, i32* %18
%375 = sub nsw i32 %373, %374
%376 = load i32, i32* %17
%377 = add nsw i32 %375, %376
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds i16, i16* %372, i64 %378
%380 = load i16, i16* %379
%381 = sext i16 %380 to i32
%382 = mul nsw i32 %371, %381
%383 = load i32, i32* %27
%384 = and i32 %383, 65535
%385 = load i16*, i16** %33
%386 = load i32, i32* %13
%387 = load i32, i32* %18
%388 = sub nsw i32 %386, %387
%389 = load i32, i32* %17
%390 = add nsw i32 %388, %389
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i16, i16* %385, i64 %391
%393 = load i16, i16* %392
%394 = sext i16 %393 to i32
%395 = mul nsw i32 %384, %394
%396 = ashr i32 %395, 16
%397 = add nsw i32 %382, %396
%398 = add nsw i32 %369, %397
store i32 %398, i32* %30
br label %399
399: ; preds = %266
%400 = load i32, i32* %17
%401 = add nsw i32 %400, 1
store i32 %401, i32* %17
br label %262
402: ; preds = %262
%403 = load i32, i32* %29
%404 = sub nsw i32 0, %403
%405 = load i32, i32* %21
%406 = sub nsw i32 8, %405
%407 = shl i32 %404, %406
store i32 %407, i32* %29
%408 = load i32, i32* %30
%409 = sub nsw i32 0, %408
%410 = load i32, i32* %21
%411 = sub nsw i32 8, %410
%412 = shl i32 %409, %411
store i32 %412, i32* %30
store i32 0, i32* %17
br label %413
413: ; preds = %488, %402
%414 = load i32, i32* %17
%415 = load i32, i32* %18
%416 = icmp sle i32 %414, %415
br i1 %416, label %417, label %491
417: ; preds = %413
%418 = load i32, i32* %17
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %419
%421 = load i32, i32* %420
%422 = load i32, i32* %29
%423 = ashr i32 %422, 16
%424 = load i16*, i16** %33
%425 = load i32, i32* %18
%426 = load i32, i32* %17
%427 = sub nsw i32 %425, %426
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds i16, i16* %424, i64 %428
%430 = load i16, i16* %429
%431 = sext i16 %430 to i32
%432 = mul nsw i32 %423, %431
%433 = load i32, i32* %29
%434 = and i32 %433, 65535
%435 = load i16*, i16** %33
%436 = load i32, i32* %18
%437 = load i32, i32* %17
%438 = sub nsw i32 %436, %437
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i16, i16* %435, i64 %439
%441 = load i16, i16* %440
%442 = sext i16 %441 to i32
%443 = mul nsw i32 %434, %442
%444 = ashr i32 %443, 16
%445 = add nsw i32 %432, %444
%446 = add nsw i32 %421, %445
%447 = load i32, i32* %17
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %448
store i32 %446, i32* %449
%450 = load i32, i32* %17
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %451
%453 = load i32, i32* %452
%454 = load i32, i32* %30
%455 = ashr i32 %454, 16
%456 = load i16*, i16** %33
%457 = load i32, i32* %13
%458 = load i32, i32* %18
%459 = sub nsw i32 %457, %458
%460 = load i32, i32* %17
%461 = add nsw i32 %459, %460
%462 = sub nsw i32 %461, 1
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds i16, i16* %456, i64 %463
%465 = load i16, i16* %464
%466 = sext i16 %465 to i32
%467 = mul nsw i32 %455, %466
%468 = load i32, i32* %30
%469 = and i32 %468, 65535
%470 = load i16*, i16** %33
%471 = load i32, i32* %13
%472 = load i32, i32* %18
%473 = sub nsw i32 %471, %472
%474 = load i32, i32* %17
%475 = add nsw i32 %473, %474
%476 = sub nsw i32 %475, 1
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds i16, i16* %470, i64 %477
%479 = load i16, i16* %478
%480 = sext i16 %479 to i32
%481 = mul nsw i32 %469, %480
%482 = ashr i32 %481, 16
%483 = add nsw i32 %467, %482
%484 = add nsw i32 %453, %483
%485 = load i32, i32* %17
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %486
store i32 %484, i32* %487
br label %488
488: ; preds = %417
%489 = load i32, i32* %17
%490 = add nsw i32 %489, 1
store i32 %490, i32* %17
br label %413
491: ; preds = %413
br label %492
492: ; preds = %491
%493 = load i32, i32* %19
%494 = add nsw i32 %493, 1
store i32 %494, i32* %19
br label %211
495: ; preds = %211
br label %780
496: ; preds = %207
store i32 0, i32* %19
br label %497
497: ; preds = %776, %496
%498 = load i32, i32* %19
%499 = load i32, i32* %14
%500 = icmp slt i32 %498, %499
br i1 %500, label %501, label %779
501: ; preds = %497
%502 = load i16*, i16** %12
%503 = load i32, i32* %19
%504 = load i32, i32* %13
%505 = mul nsw i32 %503, %504
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i16, i16* %502, i64 %506
store i16* %507, i16** %33
%508 = load i16*, i16** %33
%509 = load i32, i32* %18
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds i16, i16* %508, i64 %510
%512 = load i16, i16* %511
%513 = sext i16 %512 to i32
%514 = load i32, i32* %21
%515 = sub nsw i32 0, %514
%516 = shl i32 %513, %515
%517 = sub nsw i32 0, %516
store i32 %517, i32* %31
%518 = load i16*, i16** %33
%519 = load i32, i32* %13
%520 = load i32, i32* %18
%521 = sub nsw i32 %519, %520
%522 = sub nsw i32 %521, 1
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds i16, i16* %518, i64 %523
%525 = load i16, i16* %524
%526 = sext i16 %525 to i32
%527 = load i32, i32* %21
%528 = sub nsw i32 0, %527
%529 = shl i32 %526, %528
%530 = sub nsw i32 0, %529
store i32 %530, i32* %32
%531 = load i16*, i16** %33
%532 = load i32, i32* %18
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i16, i16* %531, i64 %533
%535 = load i16, i16* %534
%536 = sext i16 %535 to i32
%537 = shl i32 %536, 17
store i32 %537, i32* %29
%538 = load i16*, i16** %33
%539 = load i32, i32* %13
%540 = load i32, i32* %18
%541 = sub nsw i32 %539, %540
%542 = sub nsw i32 %541, 1
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds i16, i16* %538, i64 %543
%545 = load i16, i16* %544
%546 = sext i16 %545 to i32
%547 = shl i32 %546, 17
store i32 %547, i32* %30
store i32 0, i32* %17
br label %548
548: ; preds = %626, %501
%549 = load i32, i32* %17
%550 = load i32, i32* %18
%551 = icmp slt i32 %549, %550
br i1 %551, label %552, label %629
552: ; preds = %548
%553 = load i32, i32* %17
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %554
%556 = load i32, i32* %555
%557 = load i32, i32* %31
%558 = load i16*, i16** %33
%559 = load i32, i32* %18
%560 = load i32, i32* %17
%561 = sub nsw i32 %559, %560
%562 = sub nsw i32 %561, 1
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds i16, i16* %558, i64 %563
%565 = load i16, i16* %564
%566 = sext i16 %565 to i32
%567 = mul nsw i32 %557, %566
%568 = add nsw i32 %556, %567
%569 = load i32, i32* %17
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %570
store i32 %568, i32* %571
%572 = load i32, i32* %17
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds [16 x i32], [16 x i32]* %35, i64 0, i64 %573
%575 = load i32, i32* %574
%576 = load i32, i32* %32
%577 = load i16*, i16** %33
%578 = load i32, i32* %13
%579 = load i32, i32* %18
%580 = sub nsw i32 %578, %579
%581 = load i32, i32* %17
%582 = add nsw i32 %580, %581
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds i16, i16* %577, i64 %583
%585 = load i16, i16* %584
%586 = sext i16 %585 to i32
%587 = mul nsw i32 %576, %586
%588 = add nsw i32 %575, %587
%589 = load i32, i32* %17
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds [16 x i32], [16 x i32]* %35, i64 0, i64 %590
store i32 %588, i32* %591
%592 = load i32, i32* %17
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %593
%595 = load i32, i32* %594
%596 = ashr i32 %595, 6
%597 = add nsw i32 %596, 1
%598 = ashr i32 %597, 1
store i32 %598, i32* %28
%599 = load i32, i32* %29
%600 = load i16*, i16** %33
%601 = load i32, i32* %18
%602 = load i32, i32* %17
%603 = sub nsw i32 %601, %602
%604 = sub nsw i32 %603, 1
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds i16, i16* %600, i64 %605
%607 = load i16, i16* %606
%608 = sext i16 %607 to i32
%609 = load i32, i32* %28
%610 = mul nsw i32 %608, %609
%611 = add nsw i32 %599, %610
store i32 %611, i32* %29
%612 = load i32, i32* %30
%613 = load i16*, i16** %33
%614 = load i32, i32* %13
%615 = load i32, i32* %18
%616 = sub nsw i32 %614, %615
%617 = load i32, i32* %17
%618 = add nsw i32 %616, %617
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds i16, i16* %613, i64 %619
%621 = load i16, i16* %620
%622 = sext i16 %621 to i32
%623 = load i32, i32* %28
%624 = mul nsw i32 %622, %623
%625 = add nsw i32 %612, %624
store i32 %625, i32* %30
br label %626
626: ; preds = %552
%627 = load i32, i32* %17
%628 = add nsw i32 %627, 1
store i32 %628, i32* %17
br label %548
629: ; preds = %548
%630 = load i32, i32* %29
%631 = sub nsw i32 0, %630
store i32 %631, i32* %29
%632 = load i32, i32* %30
%633 = sub nsw i32 0, %632
store i32 %633, i32* %30
store i32 0, i32* %17
br label %634
634: ; preds = %772, %629
%635 = load i32, i32* %17
%636 = load i32, i32* %18
%637 = icmp sle i32 %635, %636
br i1 %637, label %638, label %775
638: ; preds = %634
%639 = load i32, i32* %17
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %640
%642 = load i32, i32* %641
%643 = load i32, i32* %29
%644 = ashr i32 %643, 16
%645 = load i16*, i16** %33
%646 = load i32, i32* %18
%647 = load i32, i32* %17
%648 = sub nsw i32 %646, %647
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds i16, i16* %645, i64 %649
%651 = load i16, i16* %650
%652 = sext i16 %651 to i32
%653 = load i32, i32* %21
%654 = sub nsw i32 0, %653
%655 = sub nsw i32 %654, 1
%656 = shl i32 %652, %655
%657 = trunc i32 %656 to i16
%658 = sext i16 %657 to i32
%659 = mul nsw i32 %644, %658
%660 = load i32, i32* %29
%661 = and i32 %660, 65535
%662 = load i16*, i16** %33
%663 = load i32, i32* %18
%664 = load i32, i32* %17
%665 = sub nsw i32 %663, %664
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds i16, i16* %662, i64 %666
%668 = load i16, i16* %667
%669 = sext i16 %668 to i32
%670 = load i32, i32* %21
%671 = sub nsw i32 0, %670
%672 = sub nsw i32 %671, 1
%673 = shl i32 %669, %672
%674 = trunc i32 %673 to i16
%675 = sext i16 %674 to i32
%676 = mul nsw i32 %661, %675
%677 = ashr i32 %676, 16
%678 = add nsw i32 %659, %677
%679 = add nsw i32 %642, %678
%680 = load i32, i32* %29
%681 = load i16*, i16** %33
%682 = load i32, i32* %18
%683 = load i32, i32* %17
%684 = sub nsw i32 %682, %683
%685 = sext i32 %684 to i64
%686 = getelementptr inbounds i16, i16* %681, i64 %685
%687 = load i16, i16* %686
%688 = sext i16 %687 to i32
%689 = load i32, i32* %21
%690 = sub nsw i32 0, %689
%691 = sub nsw i32 %690, 1
%692 = shl i32 %688, %691
%693 = ashr i32 %692, 15
%694 = add nsw i32 %693, 1
%695 = ashr i32 %694, 1
%696 = mul nsw i32 %680, %695
%697 = add nsw i32 %679, %696
%698 = load i32, i32* %17
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %699
store i32 %697, i32* %700
%701 = load i32, i32* %17
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %702
%704 = load i32, i32* %703
%705 = load i32, i32* %30
%706 = ashr i32 %705, 16
%707 = load i16*, i16** %33
%708 = load i32, i32* %13
%709 = load i32, i32* %18
%710 = sub nsw i32 %708, %709
%711 = load i32, i32* %17
%712 = add nsw i32 %710, %711
%713 = sub nsw i32 %712, 1
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds i16, i16* %707, i64 %714
%716 = load i16, i16* %715
%717 = sext i16 %716 to i32
%718 = load i32, i32* %21
%719 = sub nsw i32 0, %718
%720 = sub nsw i32 %719, 1
%721 = shl i32 %717, %720
%722 = trunc i32 %721 to i16
%723 = sext i16 %722 to i32
%724 = mul nsw i32 %706, %723
%725 = load i32, i32* %30
%726 = and i32 %725, 65535
%727 = load i16*, i16** %33
%728 = load i32, i32* %13
%729 = load i32, i32* %18
%730 = sub nsw i32 %728, %729
%731 = load i32, i32* %17
%732 = add nsw i32 %730, %731
%733 = sub nsw i32 %732, 1
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds i16, i16* %727, i64 %734
%736 = load i16, i16* %735
%737 = sext i16 %736 to i32
%738 = load i32, i32* %21
%739 = sub nsw i32 0, %738
%740 = sub nsw i32 %739, 1
%741 = shl i32 %737, %740
%742 = trunc i32 %741 to i16
%743 = sext i16 %742 to i32
%744 = mul nsw i32 %726, %743
%745 = ashr i32 %744, 16
%746 = add nsw i32 %724, %745
%747 = add nsw i32 %704, %746
%748 = load i32, i32* %30
%749 = load i16*, i16** %33
%750 = load i32, i32* %13
%751 = load i32, i32* %18
%752 = sub nsw i32 %750, %751
%753 = load i32, i32* %17
%754 = add nsw i32 %752, %753
%755 = sub nsw i32 %754, 1
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds i16, i16* %749, i64 %756
%758 = load i16, i16* %757
%759 = sext i16 %758 to i32
%760 = load i32, i32* %21
%761 = sub nsw i32 0, %760
%762 = sub nsw i32 %761, 1
%763 = shl i32 %759, %762
%764 = ashr i32 %763, 15
%765 = add nsw i32 %764, 1
%766 = ashr i32 %765, 1
%767 = mul nsw i32 %748, %766
%768 = add nsw i32 %747, %767
%769 = load i32, i32* %17
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %770
store i32 %768, i32* %771
br label %772
772: ; preds = %638
%773 = load i32, i32* %17
%774 = add nsw i32 %773, 1
store i32 %774, i32* %17
br label %634
775: ; preds = %634
br label %776
776: ; preds = %775
%777 = load i32, i32* %19
%778 = add nsw i32 %777, 1
store i32 %778, i32* %19
br label %497
779: ; preds = %497
br label %780
780: ; preds = %779, %495
%781 = load i32, i32* %18
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %782
%784 = load i32, i32* %783
store i32 %784, i32* %29
%785 = load i32, i32* %18
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds [16 x i32], [16 x i32]* %35, i64 0, i64 %786
%788 = load i32, i32* %787
store i32 %788, i32* %30
store i32 0, i32* %24
%789 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 0
%790 = load i32, i32* %789
%791 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 0
%792 = load i32, i32* %791
%793 = add nsw i32 %790, %792
store i32 %793, i32* %25
store i32 0, i32* %17
br label %794
794: ; preds = %899, %780
%795 = load i32, i32* %17
%796 = load i32, i32* %18
%797 = icmp slt i32 %795, %796
br i1 %797, label %798, label %902
798: ; preds = %794
%799 = load i32, i32* %17
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %800
%802 = load i32, i32* %801
store i32 %802, i32* %27
%803 = load i32, i32* %27
%804 = icmp sgt i32 %803, 0
br i1 %804, label %805, label %807
805: ; preds = %798
%806 = load i32, i32* %27
br label %810
807: ; preds = %798
%808 = load i32, i32* %27
%809 = sub nsw i32 0, %808
br label %810
810: ; preds = %807, %805
%811 = phi i32 [ %806, %805 ], [ %809, %807 ]
%812 = call i32 (i32, ...) bitcast (i32 (...)* @SKP_Silk_CLZ32 to i32 (i32, ...)*)(i32 %811)
%813 = sub nsw i32 %812, 1
store i32 %813, i32* %20
%814 = load i32, i32* %20
%815 = icmp slt i32 8, %814
br i1 %815, label %816, label %817
816: ; preds = %810
br label %819
817: ; preds = %810
%818 = load i32, i32* %20
br label %819
819: ; preds = %817, %816
%820 = phi i32 [ 8, %816 ], [ %818, %817 ]
store i32 %820, i32* %20
%821 = load i32, i32* %27
%822 = load i32, i32* %20
%823 = shl i32 %821, %822
store i32 %823, i32* %28
%824 = load i32, i32* %29
%825 = load i32, i32* %18
%826 = load i32, i32* %17
%827 = sub nsw i32 %825, %826
%828 = sub nsw i32 %827, 1
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds [16 x i32], [16 x i32]* %35, i64 0, i64 %829
%831 = load i32, i32* %830
%832 = sext i32 %831 to i64
%833 = load i32, i32* %28
%834 = sext i32 %833 to i64
%835 = mul nsw i64 %832, %834
%836 = ashr i64 %835, 32
%837 = trunc i64 %836 to i32
%838 = load i32, i32* %20
%839 = sub nsw i32 8, %838
%840 = shl i32 %837, %839
%841 = add nsw i32 %824, %840
store i32 %841, i32* %29
%842 = load i32, i32* %30
%843 = load i32, i32* %18
%844 = load i32, i32* %17
%845 = sub nsw i32 %843, %844
%846 = sub nsw i32 %845, 1
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds [16 x i32], [16 x i32]* %34, i64 0, i64 %847
%849 = load i32, i32* %848
%850 = sext i32 %849 to i64
%851 = load i32, i32* %28
%852 = sext i32 %851 to i64
%853 = mul nsw i64 %850, %852
%854 = ashr i64 %853, 32
%855 = trunc i64 %854 to i32
%856 = load i32, i32* %20
%857 = sub nsw i32 8, %856
%858 = shl i32 %855, %857
%859 = add nsw i32 %842, %858
store i32 %859, i32* %30
%860 = load i32, i32* %24
%861 = load i32, i32* %18
%862 = load i32, i32* %17
%863 = sub nsw i32 %861, %862
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %864
%866 = load i32, i32* %865
%867 = sext i32 %866 to i64
%868 = load i32, i32* %28
%869 = sext i32 %868 to i64
%870 = mul nsw i64 %867, %869
%871 = ashr i64 %870, 32
%872 = trunc i64 %871 to i32
%873 = load i32, i32* %20
%874 = sub nsw i32 8, %873
%875 = shl i32 %872, %874
%876 = add nsw i32 %860, %875
store i32 %876, i32* %24
%877 = load i32, i32* %25
%878 = load i32, i32* %17
%879 = add nsw i32 %878, 1
%880 = sext i32 %879 to i64
%881 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %880
%882 = load i32, i32* %881
%883 = load i32, i32* %17
%884 = add nsw i32 %883, 1
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %885
%887 = load i32, i32* %886
%888 = add nsw i32 %882, %887
%889 = sext i32 %888 to i64
%890 = load i32, i32* %28
%891 = sext i32 %890 to i64
%892 = mul nsw i64 %889, %891
%893 = ashr i64 %892, 32
%894 = trunc i64 %893 to i32
%895 = load i32, i32* %20
%896 = sub nsw i32 8, %895
%897 = shl i32 %894, %896
%898 = add nsw i32 %877, %897
store i32 %898, i32* %25
br label %899
899: ; preds = %819
%900 = load i32, i32* %17
%901 = add nsw i32 %900, 1
store i32 %901, i32* %17
br label %794
902: ; preds = %794
%903 = load i32, i32* %29
%904 = load i32, i32* %18
%905 = add nsw i32 %904, 1
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %906
store i32 %903, i32* %907
%908 = load i32, i32* %30
%909 = load i32, i32* %18
%910 = add nsw i32 %909, 1
%911 = sext i32 %910 to i64
%912 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %911
store i32 %908, i32* %912
%913 = load i32, i32* %24
%914 = load i32, i32* %30
%915 = add nsw i32 %913, %914
store i32 %915, i32* %24
%916 = load i32, i32* %24
%917 = sub nsw i32 0, %916
%918 = shl i32 %917, 1
store i32 %918, i32* %24
%919 = load i32, i32* %24
%920 = icmp sgt i32 %919, 0
br i1 %920, label %921, label %923
921: ; preds = %902
%922 = load i32, i32* %24
br label %926
923: ; preds = %902
%924 = load i32, i32* %24
%925 = sub nsw i32 0, %924
br label %926
926: ; preds = %923, %921
%927 = phi i32 [ %922, %921 ], [ %925, %923 ]
%928 = load i32, i32* %25
%929 = icmp slt i32 %927, %928
br i1 %929, label %930, label %934
930: ; preds = %926
%931 = load i32, i32* %24
%932 = load i32, i32* %25
%933 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @SKP_DIV32_varQ to i32 (i32, i32, i32, ...)*)(i32 %931, i32 %932, i32 31)
store i32 %933, i32* %26
br label %944
934: ; preds = %926
%935 = load i32, i32* %18
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %936
%938 = bitcast i32* %937 to i8*
%939 = load i32, i32* %16
%940 = load i32, i32* %18
%941 = sub nsw i32 %939, %940
%942 = sext i32 %941 to i64
%943 = mul i64 %942, 4
br label %1054
944: ; preds = %930
store i32 0, i32* %17
br label %945
945: ; preds = %992, %944
%946 = load i32, i32* %17
%947 = load i32, i32* %18
%948 = add nsw i32 %947, 1
%949 = ashr i32 %948, 1
%950 = icmp slt i32 %946, %949
br i1 %950, label %951, label %995
951: ; preds = %945
%952 = load i32, i32* %17
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %953
%955 = load i32, i32* %954
store i32 %955, i32* %29
%956 = load i32, i32* %18
%957 = load i32, i32* %17
%958 = sub nsw i32 %956, %957
%959 = sub nsw i32 %958, 1
%960 = sext i32 %959 to i64
%961 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %960
%962 = load i32, i32* %961
store i32 %962, i32* %30
%963 = load i32, i32* %29
%964 = load i32, i32* %30
%965 = sext i32 %964 to i64
%966 = load i32, i32* %26
%967 = sext i32 %966 to i64
%968 = mul nsw i64 %965, %967
%969 = ashr i64 %968, 32
%970 = trunc i64 %969 to i32
%971 = shl i32 %970, 1
%972 = add nsw i32 %963, %971
%973 = load i32, i32* %17
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %974
store i32 %972, i32* %975
%976 = load i32, i32* %30
%977 = load i32, i32* %29
%978 = sext i32 %977 to i64
%979 = load i32, i32* %26
%980 = sext i32 %979 to i64
%981 = mul nsw i64 %978, %980
%982 = ashr i64 %981, 32
%983 = trunc i64 %982 to i32
%984 = shl i32 %983, 1
%985 = add nsw i32 %976, %984
%986 = load i32, i32* %18
%987 = load i32, i32* %17
%988 = sub nsw i32 %986, %987
%989 = sub nsw i32 %988, 1
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %990
store i32 %985, i32* %991
br label %992
992: ; preds = %951
%993 = load i32, i32* %17
%994 = add nsw i32 %993, 1
store i32 %994, i32* %17
br label %945
995: ; preds = %945
%996 = load i32, i32* %26
%997 = ashr i32 %996, 7
%998 = load i32, i32* %18
%999 = sext i32 %998 to i64
%1000 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %999
store i32 %997, i32* %1000
store i32 0, i32* %17
br label %1001
1001: ; preds = %1047, %995
%1002 = load i32, i32* %17
%1003 = load i32, i32* %18
%1004 = add nsw i32 %1003, 1
%1005 = icmp sle i32 %1002, %1004
br i1 %1005, label %1006, label %1050
1006: ; preds = %1001
%1007 = load i32, i32* %17
%1008 = sext i32 %1007 to i64
%1009 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %1008
%1010 = load i32, i32* %1009
store i32 %1010, i32* %29
%1011 = load i32, i32* %18
%1012 = load i32, i32* %17
%1013 = sub nsw i32 %1011, %1012
%1014 = add nsw i32 %1013, 1
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %1015
%1017 = load i32, i32* %1016
store i32 %1017, i32* %30
%1018 = load i32, i32* %29
%1019 = load i32, i32* %30
%1020 = sext i32 %1019 to i64
%1021 = load i32, i32* %26
%1022 = sext i32 %1021 to i64
%1023 = mul nsw i64 %1020, %1022
%1024 = ashr i64 %1023, 32
%1025 = trunc i64 %1024 to i32
%1026 = shl i32 %1025, 1
%1027 = add nsw i32 %1018, %1026
%1028 = load i32, i32* %17
%1029 = sext i32 %1028 to i64
%1030 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %1029
store i32 %1027, i32* %1030
%1031 = load i32, i32* %30
%1032 = load i32, i32* %29
%1033 = sext i32 %1032 to i64
%1034 = load i32, i32* %26
%1035 = sext i32 %1034 to i64
%1036 = mul nsw i64 %1033, %1035
%1037 = ashr i64 %1036, 32
%1038 = trunc i64 %1037 to i32
%1039 = shl i32 %1038, 1
%1040 = add nsw i32 %1031, %1039
%1041 = load i32, i32* %18
%1042 = load i32, i32* %17
%1043 = sub nsw i32 %1041, %1042
%1044 = add nsw i32 %1043, 1
%1045 = sext i32 %1044 to i64
%1046 = getelementptr inbounds [17 x i32], [17 x i32]* %38, i64 0, i64 %1045
store i32 %1040, i32* %1046
br label %1047
1047: ; preds = %1006
%1048 = load i32, i32* %17
%1049 = add nsw i32 %1048, 1
store i32 %1049, i32* %17
br label %1001
1050: ; preds = %1001
br label %1051
1051: ; preds = %1050
%1052 = load i32, i32* %18
%1053 = add nsw i32 %1052, 1
store i32 %1053, i32* %18
br label %203
1054: ; preds = %934, %203
%1055 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 0
%1056 = load i32, i32* %1055
store i32 %1056, i32* %25
store i32 65536, i32* %29
store i32 0, i32* %17
br label %1057
1057: ; preds = %1133, %1054
%1058 = load i32, i32* %17
%1059 = load i32, i32* %16
%1060 = icmp slt i32 %1058, %1059
br i1 %1060, label %1061, label %1136
1061: ; preds = %1057
%1062 = load i32, i32* %17
%1063 = sext i32 %1062 to i64
%1064 = getelementptr inbounds [16 x i32], [16 x i32]* %36, i64 0, i64 %1063
%1065 = load i32, i32* %1064
%1066 = ashr i32 %1065, 7
%1067 = add nsw i32 %1066, 1
%1068 = ashr i32 %1067, 1
store i32 %1068, i32* %28
%1069 = load i32, i32* %25
%1070 = load i32, i32* %17
%1071 = add nsw i32 %1070, 1
%1072 = sext i32 %1071 to i64
%1073 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %1072
%1074 = load i32, i32* %1073
%1075 = ashr i32 %1074, 16
%1076 = load i32, i32* %28
%1077 = trunc i32 %1076 to i16
%1078 = sext i16 %1077 to i32
%1079 = mul nsw i32 %1075, %1078
%1080 = load i32, i32* %17
%1081 = add nsw i32 %1080, 1
%1082 = sext i32 %1081 to i64
%1083 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %1082
%1084 = load i32, i32* %1083
%1085 = and i32 %1084, 65535
%1086 = load i32, i32* %28
%1087 = trunc i32 %1086 to i16
%1088 = sext i16 %1087 to i32
%1089 = mul nsw i32 %1085, %1088
%1090 = ashr i32 %1089, 16
%1091 = add nsw i32 %1079, %1090
%1092 = add nsw i32 %1069, %1091
%1093 = load i32, i32* %17
%1094 = add nsw i32 %1093, 1
%1095 = sext i32 %1094 to i64
%1096 = getelementptr inbounds [17 x i32], [17 x i32]* %37, i64 0, i64 %1095
%1097 = load i32, i32* %1096
%1098 = load i32, i32* %28
%1099 = ashr i32 %1098, 15
%1100 = add nsw i32 %1099, 1
%1101 = ashr i32 %1100, 1
%1102 = mul nsw i32 %1097, %1101
%1103 = add nsw i32 %1092, %1102
store i32 %1103, i32* %25
%1104 = load i32, i32* %29
%1105 = load i32, i32* %28
%1106 = ashr i32 %1105, 16
%1107 = load i32, i32* %28
%1108 = trunc i32 %1107 to i16
%1109 = sext i16 %1108 to i32
%1110 = mul nsw i32 %1106, %1109
%1111 = load i32, i32* %28
%1112 = and i32 %1111, 65535
%1113 = load i32, i32* %28
%1114 = trunc i32 %1113 to i16
%1115 = sext i16 %1114 to i32
%1116 = mul nsw i32 %1112, %1115
%1117 = ashr i32 %1116, 16
%1118 = add nsw i32 %1110, %1117
%1119 = add nsw i32 %1104, %1118
%1120 = load i32, i32* %28
%1121 = load i32, i32* %28
%1122 = ashr i32 %1121, 15
%1123 = add nsw i32 %1122, 1
%1124 = ashr i32 %1123, 1
%1125 = mul nsw i32 %1120, %1124
%1126 = add nsw i32 %1119, %1125
store i32 %1126, i32* %29
%1127 = load i32, i32* %28
%1128 = sub nsw i32 0, %1127
%1129 = load i32*, i32** %11
%1130 = load i32, i32* %17
%1131 = sext i32 %1130 to i64
%1132 = getelementptr inbounds i32, i32* %1129, i64 %1131
store i32 %1128, i32* %1132
br label %1133
1133: ; preds = %1061
%1134 = load i32, i32* %17
%1135 = add nsw i32 %1134, 1
store i32 %1135, i32* %17
br label %1057
1136: ; preds = %1057
%1137 = load i32, i32* %25
%1138 = load i32, i32* %15
%1139 = sext i32 %1138 to i64
%1140 = load i32, i32* %23
%1141 = sext i32 %1140 to i64
%1142 = mul nsw i64 %1139, %1141
%1143 = ashr i64 %1142, 32
%1144 = trunc i64 %1143 to i32
%1145 = ashr i32 %1144, 16
%1146 = load i32, i32* %29
%1147 = sub nsw i32 0, %1146
%1148 = trunc i32 %1147 to i16
%1149 = sext i16 %1148 to i32
%1150 = mul nsw i32 %1145, %1149
%1151 = load i32, i32* %15
%1152 = sext i32 %1151 to i64
%1153 = load i32, i32* %23
%1154 = sext i32 %1153 to i64
%1155 = mul nsw i64 %1152, %1154
%1156 = ashr i64 %1155, 32
%1157 = trunc i64 %1156 to i32
%1158 = and i32 %1157, 65535
%1159 = load i32, i32* %29
%1160 = sub nsw i32 0, %1159
%1161 = trunc i32 %1160 to i16
%1162 = sext i16 %1161 to i32
%1163 = mul nsw i32 %1158, %1162
%1164 = ashr i32 %1163, 16
%1165 = add nsw i32 %1150, %1164
%1166 = add nsw i32 %1137, %1165
%1167 = load i32, i32* %15
%1168 = sext i32 %1167 to i64
%1169 = load i32, i32* %23
%1170 = sext i32 %1169 to i64
%1171 = mul nsw i64 %1168, %1170
%1172 = ashr i64 %1171, 32
%1173 = trunc i64 %1172 to i32
%1174 = load i32, i32* %29
%1175 = sub nsw i32 0, %1174
%1176 = ashr i32 %1175, 15
%1177 = add nsw i32 %1176, 1
%1178 = ashr i32 %1177, 1
%1179 = mul nsw i32 %1173, %1178
%1180 = add nsw i32 %1166, %1179
%1181 = load i32*, i32** %9
store i32 %1180, i32* %1181
%1182 = load i32, i32* %21
%1183 = sub nsw i32 0, %1182
%1184 = load i32*, i32** %10
store i32 %1183, i32* %1184
ret void
}

LLVM IR (-O2):
define void @SKP_Silk_burg_modified(i32* nocapture writeonly %0, i32* nocapture writeonly %1, i32* nocapture writeonly %2, i16* %3, i32 %4, i32 %5, i32 %6, i32 %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca [16 x i32]
%12 = alloca [16 x i32]
%13 = alloca [16 x i32]
%14 = alloca [17 x i32]
%15 = alloca [17 x i32]
%16 = bitcast i32* %9 to i8*
%17 = bitcast i32* %10 to i8*
%18 = bitcast [16 x i32]* %11 to i8*
%19 = bitcast [16 x i32]* %12 to i8*
%20 = bitcast [16 x i32]* %13 to i8*
%21 = bitcast [17 x i32]* %14 to i8*
%22 = bitcast [17 x i32]* %15 to i8*
%23 = mul nsw i32 %5, %4
%24 = call i32 (i32*, i32*, i16*, i32, ...) bitcast (i32 (...)* @SKP_Silk_sum_sqr_shift to i32 (i32*, i32*, i16*, i32, ...)*)(i32* %10, i32* %9, i16* %3, i32 %23)
%25 = load i32, i32* %9
%26 = icmp sgt i32 %25, 8
%27 = load i32, i32* %10
br i1 %26, label %28, label %31
28: ; preds = %8
%29 = add nsw i32 %25, -8
%30 = shl i32 %27, %29
store i32 %30, i32* %10
store i32 8, i32* %9
br label %62
31: ; preds = %8
%32 = call i32 (i32, ...) bitcast (i32 (...)* @SKP_Silk_CLZ32 to i32 (i32, ...)*)(i32 %27)
%33 = sub i32 3, %32
%34 = icmp sgt i32 %33, 0
%35 = load i32, i32* %9
br i1 %34, label %36, label %42
36: ; preds = %31
%37 = sub nsw i32 8, %35
%38 = icmp slt i32 %33, %37
%39 = select i1 %38, i32 %33, i32 %37
%40 = load i32, i32* %10
%41 = ashr i32 %40, %39
br label %49
42: ; preds = %31
%43 = sub nsw i32 -16, %35
%44 = icmp sgt i32 %33, %43
%45 = select i1 %44, i32 %33, i32 %43
%46 = load i32, i32* %10
%47 = sub nsw i32 0, %45
%48 = shl i32 %46, %47
br label %49
49: ; preds = %36, %42
%50 = phi i32 [ %48, %42 ], [ %41, %36 ]
%51 = phi i32 [ %45, %42 ], [ %39, %36 ]
store i32 %50, i32* %10
%52 = add nsw i32 %35, %51
store i32 %52, i32* %9
%53 = icmp sgt i32 %52, 0
br i1 %53, label %62, label %54
54: ; preds = %49
%55 = icmp sgt i32 %5, 0
br i1 %55, label %56, label %118
56: ; preds = %54
%57 = icmp slt i32 %7, 1
%58 = sext i32 %4 to i64
%59 = add i32 %7, 1
%60 = zext i32 %5 to i64
%61 = zext i32 %59 to i64
br label %94
62: ; preds = %28, %49
%63 = phi i32 [ 8, %28 ], [ %52, %49 ]
%64 = icmp sgt i32 %5, 0
br i1 %64, label %65, label %118
65: ; preds = %62
%66 = icmp slt i32 %7, 1
%67 = sext i32 %4 to i64
%68 = add i32 %7, 1
%69 = zext i32 %5 to i64
%70 = zext i32 %68 to i64
br label %71
71: ; preds = %65, %90
%72 = phi i32 [ %63, %65 ], [ %91, %90 ]
%73 = phi i64 [ 0, %65 ], [ %92, %90 ]
%74 = mul nsw i64 %73, %67
%75 = getelementptr inbounds i16, i16* %3, i64 %74
br i1 %66, label %90, label %76
76: ; preds = %71, %76
%77 = phi i64 [ %88, %76 ], [ 1, %71 ]
%78 = getelementptr inbounds i16, i16* %75, i64 %77
%79 = trunc i64 %77 to i32
%80 = sub i32 %4, %79
%81 = call i32 (i16*, i16*, i32, ...) bitcast (i32 (...)* @SKP_Silk_inner_prod16_aligned_64 to i32 (i16*, i16*, i32, ...)*)(i16* %75, i16* %78, i32 %80)
%82 = load i32, i32* %9
%83 = ashr i32 %81, %82
%84 = add nsw i64 %77, -1
%85 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %84
%86 = load i32, i32* %85
%87 = add nsw i32 %86, %83
store i32 %87, i32* %85
%88 = add nuw nsw i64 %77, 1
%89 = icmp eq i64 %88, %70
br i1 %89, label %90, label %76
90: ; preds = %76, %71
%91 = phi i32 [ %72, %71 ], [ %82, %76 ]
%92 = add nuw nsw i64 %73, 1
%93 = icmp eq i64 %92, %69
br i1 %93, label %118, label %71
94: ; preds = %56, %114
%95 = phi i32 [ %52, %56 ], [ %115, %114 ]
%96 = phi i64 [ 0, %56 ], [ %116, %114 ]
%97 = mul nsw i64 %96, %58
%98 = getelementptr inbounds i16, i16* %3, i64 %97
br i1 %57, label %114, label %99
99: ; preds = %94, %99
%100 = phi i64 [ %112, %99 ], [ 1, %94 ]
%101 = getelementptr inbounds i16, i16* %98, i64 %100
%102 = trunc i64 %100 to i32
%103 = sub i32 %4, %102
%104 = call i32 (i16*, i16*, i32, ...) bitcast (i32 (...)* @SKP_Silk_inner_prod_aligned to i32 (i16*, i16*, i32, ...)*)(i16* %98, i16* %101, i32 %103)
%105 = load i32, i32* %9
%106 = sub nsw i32 0, %105
%107 = shl i32 %104, %106
%108 = add nsw i64 %100, -1
%109 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %108
%110 = load i32, i32* %109
%111 = add nsw i32 %110, %107
store i32 %111, i32* %109
%112 = add nuw nsw i64 %100, 1
%113 = icmp eq i64 %112, %61
br i1 %113, label %114, label %99
114: ; preds = %99, %94
%115 = phi i32 [ %95, %94 ], [ %105, %99 ]
%116 = add nuw nsw i64 %96, 1
%117 = icmp eq i64 %116, %60
br i1 %117, label %118, label %94
118: ; preds = %114, %90, %54, %62
%119 = phi i32 [ %52, %54 ], [ %63, %62 ], [ %91, %90 ], [ %115, %114 ]
%120 = load i32, i32* %10
%121 = sext i32 %6 to i64
%122 = sext i32 %120 to i64
%123 = mul nsw i64 %122, %121
%124 = lshr i64 %123, 32
%125 = trunc i64 %124 to i32
%126 = add i32 %120, 1
%127 = add i32 %126, %125
%128 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 0
store i32 %127, i32* %128
%129 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 0
store i32 %127, i32* %129
%130 = icmp sgt i32 %7, 0
br i1 %130, label %133, label %131
131: ; preds = %118
%132 = load i32, i32* %128
br label %1023
133: ; preds = %118
%134 = icmp sgt i32 %5, 0
%135 = sext i32 %4 to i64
%136 = zext i32 %7 to i64
%137 = zext i32 %5 to i64
%138 = zext i32 %5 to i64
%139 = add i32 %4, -1
br label %146
140: ; preds = %906, %902
%141 = icmp eq i64 %820, %136
br i1 %141, label %927, label %142
142: ; preds = %140
%143 = add nuw nsw i64 %150, 1
%144 = add nuw nsw i64 %149, 1
%145 = load i32, i32* %9
br label %146
146: ; preds = %142, %133
%147 = phi i32 [ %119, %133 ], [ %145, %142 ]
%148 = phi i64 [ 0, %133 ], [ %820, %142 ]
%149 = phi i64 [ 1, %133 ], [ %144, %142 ]
%150 = phi i64 [ 2, %133 ], [ %143, %142 ]
%151 = trunc i64 %148 to i32
%152 = sub i32 %139, %151
%153 = trunc i64 %148 to i32
%154 = sub i32 %139, %153
%155 = icmp sgt i32 %147, -2
br i1 %155, label %177, label %156
156: ; preds = %146
br i1 %134, label %157, label %751
157: ; preds = %156
%158 = sub nsw i32 0, %147
%159 = sub nsw i64 %135, %148
%160 = add nsw i64 %159, -1
%161 = icmp eq i64 %148, 0
%162 = xor i32 %147, -1
%163 = add i64 %159, 4294967295
%164 = icmp ult i64 %148, 8
%165 = and i64 %148, 9223372036854775800
%166 = icmp eq i64 %148, %165
%167 = icmp ult i64 %149, 4
%168 = trunc i64 %148 to i32
%169 = add i32 %152, %168
%170 = icmp slt i32 %169, %152
%171 = icmp ugt i64 %148, 4294967295
%172 = or i1 %170, %171
%173 = and i64 %149, 9223372036854775804
%174 = insertelement <4 x i32> poison, i32 %162, i64 0
%175 = shufflevector <4 x i32> %174, <4 x i32> poison, <4 x i32> zeroinitializer
%176 = icmp eq i64 %149, %173
br label %480
177: ; preds = %146
br i1 %134, label %178, label %751
178: ; preds = %177
%179 = sub nsw i32 16, %147
%180 = sub nsw i64 %135, %148
%181 = add nsw i64 %180, -1
%182 = icmp eq i64 %148, 0
%183 = sub nsw i32 8, %147
%184 = add i64 %180, 4294967295
%185 = icmp ult i64 %148, 8
%186 = and i64 %148, 9223372036854775800
%187 = icmp eq i64 %148, %186
%188 = icmp ult i64 %149, 4
%189 = trunc i64 %148 to i32
%190 = add i32 %154, %189
%191 = icmp slt i32 %190, %154
%192 = icmp ugt i64 %148, 4294967295
%193 = or i1 %191, %192
%194 = and i64 %149, 9223372036854775804
%195 = icmp eq i64 %149, %194
br label %196
196: ; preds = %178, %477
%197 = phi i64 [ 0, %178 ], [ %478, %477 ]
%198 = mul nsw i64 %197, %135
%199 = getelementptr inbounds i16, i16* %3, i64 %198
%200 = getelementptr inbounds i16, i16* %199, i64 %148
%201 = load i16, i16* %200
%202 = sext i16 %201 to i32
%203 = shl i32 %202, %179
%204 = sub nsw i32 0, %203
%205 = getelementptr inbounds i16, i16* %199, i64 %181
%206 = load i16, i16* %205
%207 = sext i16 %206 to i32
%208 = shl i32 %207, %179
%209 = sub nsw i32 0, %208
%210 = shl nsw i32 %202, 8
%211 = shl nsw i32 %207, 8
br i1 %182, label %389, label %212
212: ; preds = %196
%213 = ashr i32 %204, 16
%214 = and i32 %204, 65535
%215 = ashr i32 %209, 16
%216 = and i32 %209, 65535
br i1 %185, label %340, label %217
217: ; preds = %212
%218 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %211, i64 0
%219 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %210, i64 0
%220 = insertelement <4 x i32> poison, i32 %213, i64 0
%221 = shufflevector <4 x i32> %220, <4 x i32> poison, <4 x i32> zeroinitializer
%222 = insertelement <4 x i32> poison, i32 %213, i64 0
%223 = shufflevector <4 x i32> %222, <4 x i32> poison, <4 x i32> zeroinitializer
%224 = insertelement <4 x i32> poison, i32 %214, i64 0
%225 = shufflevector <4 x i32> %224, <4 x i32> poison, <4 x i32> zeroinitializer
%226 = insertelement <4 x i32> poison, i32 %214, i64 0
%227 = shufflevector <4 x i32> %226, <4 x i32> poison, <4 x i32> zeroinitializer
%228 = insertelement <4 x i32> poison, i32 %215, i64 0
%229 = shufflevector <4 x i32> %228, <4 x i32> poison, <4 x i32> zeroinitializer
%230 = insertelement <4 x i32> poison, i32 %215, i64 0
%231 = shufflevector <4 x i32> %230, <4 x i32> poison, <4 x i32> zeroinitializer
%232 = insertelement <4 x i32> poison, i32 %216, i64 0
%233 = shufflevector <4 x i32> %232, <4 x i32> poison, <4 x i32> zeroinitializer
%234 = insertelement <4 x i32> poison, i32 %216, i64 0
%235 = shufflevector <4 x i32> %234, <4 x i32> poison, <4 x i32> zeroinitializer
br label %236
236: ; preds = %236, %217
%237 = phi i64 [ 0, %217 ], [ %333, %236 ]
%238 = phi <4 x i32> [ %218, %217 ], [ %331, %236 ]
%239 = phi <4 x i32> [ zeroinitializer, %217 ], [ %332, %236 ]
%240 = phi <4 x i32> [ %219, %217 ], [ %321, %236 ]
%241 = phi <4 x i32> [ zeroinitializer, %217 ], [ %322, %236 ]
%242 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %237
%243 = bitcast i32* %242 to <4 x i32>*
%244 = load <4 x i32>, <4 x i32>* %243
%245 = getelementptr inbounds i32, i32* %242, i64 4
%246 = bitcast i32* %245 to <4 x i32>*
%247 = load <4 x i32>, <4 x i32>* %246
%248 = xor i64 %237, -1
%249 = add nsw i64 %148, %248
%250 = getelementptr inbounds i16, i16* %199, i64 %249
%251 = getelementptr inbounds i16, i16* %250, i64 -3
%252 = bitcast i16* %251 to <4 x i16>*
%253 = load <4 x i16>, <4 x i16>* %252
%254 = shufflevector <4 x i16> %253, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%255 = getelementptr inbounds i16, i16* %250, i64 -4
%256 = getelementptr inbounds i16, i16* %255, i64 -3
%257 = bitcast i16* %256 to <4 x i16>*
%258 = load <4 x i16>, <4 x i16>* %257
%259 = shufflevector <4 x i16> %258, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%260 = sext <4 x i16> %254 to <4 x i32>
%261 = sext <4 x i16> %259 to <4 x i32>
%262 = mul nsw <4 x i32> %221, %260
%263 = mul nsw <4 x i32> %223, %261
%264 = mul nsw <4 x i32> %225, %260
%265 = mul nsw <4 x i32> %227, %261
%266 = ashr <4 x i32> %264, <i32 16, i32 16, i32 16, i32 16>
%267 = ashr <4 x i32> %265, <i32 16, i32 16, i32 16, i32 16>
%268 = add <4 x i32> %262, %244
%269 = add <4 x i32> %263, %247
%270 = add <4 x i32> %268, %266
%271 = add <4 x i32> %269, %267
%272 = bitcast i32* %242 to <4 x i32>*
store <4 x i32> %270, <4 x i32>* %272
%273 = bitcast i32* %245 to <4 x i32>*
store <4 x i32> %271, <4 x i32>* %273
%274 = getelementptr inbounds [16 x i32], [16 x i32]* %12, i64 0, i64 %237
%275 = bitcast i32* %274 to <4 x i32>*
%276 = load <4 x i32>, <4 x i32>* %275
%277 = getelementptr inbounds i32, i32* %274, i64 4
%278 = bitcast i32* %277 to <4 x i32>*
%279 = load <4 x i32>, <4 x i32>* %278
%280 = shl i64 %237, 32
%281 = ashr exact i64 %280, 32
%282 = add nsw i64 %281, %180
%283 = getelementptr inbounds i16, i16* %199, i64 %282
%284 = bitcast i16* %283 to <4 x i16>*
%285 = load <4 x i16>, <4 x i16>* %284
%286 = getelementptr inbounds i16, i16* %283, i64 4
%287 = bitcast i16* %286 to <4 x i16>*
%288 = load <4 x i16>, <4 x i16>* %287
%289 = sext <4 x i16> %285 to <4 x i32>
%290 = sext <4 x i16> %288 to <4 x i32>
%291 = mul nsw <4 x i32> %229, %289
%292 = mul nsw <4 x i32> %231, %290
%293 = mul nsw <4 x i32> %233, %289
%294 = mul nsw <4 x i32> %235, %290
%295 = ashr <4 x i32> %293, <i32 16, i32 16, i32 16, i32 16>
%296 = ashr <4 x i32> %294, <i32 16, i32 16, i32 16, i32 16>
%297 = add <4 x i32> %291, %276
%298 = add <4 x i32> %292, %279
%299 = add <4 x i32> %297, %295
%300 = add <4 x i32> %298, %296
%301 = bitcast i32* %274 to <4 x i32>*
store <4 x i32> %299, <4 x i32>* %301
%302 = bitcast i32* %277 to <4 x i32>*
store <4 x i32> %300, <4 x i32>* %302
%303 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %237
%304 = bitcast i32* %303 to <4 x i32>*
%305 = load <4 x i32>, <4 x i32>* %304
%306 = getelementptr inbounds i32, i32* %303, i64 4
%307 = bitcast i32* %306 to <4 x i32>*
%308 = load <4 x i32>, <4 x i32>* %307
%309 = ashr <4 x i32> %305, <i32 16, i32 16, i32 16, i32 16>
%310 = ashr <4 x i32> %308, <i32 16, i32 16, i32 16, i32 16>
%311 = mul nsw <4 x i32> %309, %260
%312 = mul nsw <4 x i32> %310, %261
%313 = and <4 x i32> %305, <i32 65535, i32 65535, i32 65535, i32 65535>
%314 = and <4 x i32> %308, <i32 65535, i32 65535, i32 65535, i32 65535>
%315 = mul nsw <4 x i32> %313, %260
%316 = mul nsw <4 x i32> %314, %261
%317 = ashr <4 x i32> %315, <i32 16, i32 16, i32 16, i32 16>
%318 = ashr <4 x i32> %316, <i32 16, i32 16, i32 16, i32 16>
%319 = add <4 x i32> %311, %240
%320 = add <4 x i32> %312, %241
%321 = add <4 x i32> %319, %317
%322 = add <4 x i32> %320, %318
%323 = mul nsw <4 x i32> %309, %289
%324 = mul nsw <4 x i32> %310, %290
%325 = mul nsw <4 x i32> %313, %289
%326 = mul nsw <4 x i32> %314, %290
%327 = ashr <4 x i32> %325, <i32 16, i32 16, i32 16, i32 16>
%328 = ashr <4 x i32> %326, <i32 16, i32 16, i32 16, i32 16>
%329 = add <4 x i32> %323, %238
%330 = add <4 x i32> %324, %239
%331 = add <4 x i32> %329, %327
%332 = add <4 x i32> %330, %328
%333 = add nuw i64 %237, 8
%334 = icmp eq i64 %333, %186
br i1 %334, label %335, label %236
335: ; preds = %236
%336 = add <4 x i32> %322, %321
%337 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %336)
%338 = add <4 x i32> %332, %331
%339 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %338)
br i1 %187, label %389, label %340
340: ; preds = %212, %335
%341 = phi i64 [ 0, %212 ], [ %186, %335 ]
%342 = phi i32 [ %211, %212 ], [ %339, %335 ]
%343 = phi i32 [ %210, %212 ], [ %337, %335 ]
br label %344
344: ; preds = %340, %344
%345 = phi i64 [ %387, %344 ], [ %341, %340 ]
%346 = phi i32 [ %386, %344 ], [ %342, %340 ]
%347 = phi i32 [ %381, %344 ], [ %343, %340 ]
%348 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %345
%349 = load i32, i32* %348
%350 = xor i64 %345, -1
%351 = add nsw i64 %148, %350
%352 = getelementptr inbounds i16, i16* %199, i64 %351
%353 = load i16, i16* %352
%354 = sext i16 %353 to i32
%355 = mul nsw i32 %213, %354
%356 = mul nsw i32 %214, %354
%357 = ashr i32 %356, 16
%358 = add i32 %355, %349
%359 = add i32 %358, %357
store i32 %359, i32* %348
%360 = getelementptr inbounds [16 x i32], [16 x i32]* %12, i64 0, i64 %345
%361 = load i32, i32* %360
%362 = shl i64 %345, 32
%363 = ashr exact i64 %362, 32
%364 = add nsw i64 %363, %180
%365 = getelementptr inbounds i16, i16* %199, i64 %364
%366 = load i16, i16* %365
%367 = sext i16 %366 to i32
%368 = mul nsw i32 %215, %367
%369 = mul nsw i32 %216, %367
%370 = ashr i32 %369, 16
%371 = add i32 %368, %361
%372 = add i32 %371, %370
store i32 %372, i32* %360
%373 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %345
%374 = load i32, i32* %373
%375 = ashr i32 %374, 16
%376 = mul nsw i32 %375, %354
%377 = and i32 %374, 65535
%378 = mul nsw i32 %377, %354
%379 = ashr i32 %378, 16
%380 = add i32 %376, %347
%381 = add i32 %380, %379
%382 = mul nsw i32 %375, %367
%383 = mul nsw i32 %377, %367
%384 = ashr i32 %383, 16
%385 = add i32 %382, %346
%386 = add i32 %385, %384
%387 = add nuw nsw i64 %345, 1
%388 = icmp eq i64 %387, %148
br i1 %388, label %389, label %344
389: ; preds = %344, %335, %196
%390 = phi i32 [ %210, %196 ], [ %337, %335 ], [ %381, %344 ]
%391 = phi i32 [ %211, %196 ], [ %339, %335 ], [ %386, %344 ]
%392 = sub nsw i32 0, %390
%393 = shl i32 %392, %183
%394 = sub nsw i32 0, %391
%395 = shl i32 %394, %183
%396 = ashr i32 %393, 16
%397 = and i32 %393, 65535
%398 = ashr i32 %395, 16
%399 = and i32 %395, 65535
%400 = select i1 %188, i1 true, i1 %193
br i1 %400, label %447, label %401
401: ; preds = %389
%402 = insertelement <4 x i32> poison, i32 %396, i64 0
%403 = shufflevector <4 x i32> %402, <4 x i32> poison, <4 x i32> zeroinitializer
%404 = insertelement <4 x i32> poison, i32 %397, i64 0
%405 = shufflevector <4 x i32> %404, <4 x i32> poison, <4 x i32> zeroinitializer
%406 = insertelement <4 x i32> poison, i32 %398, i64 0
%407 = shufflevector <4 x i32> %406, <4 x i32> poison, <4 x i32> zeroinitializer
%408 = insertelement <4 x i32> poison, i32 %399, i64 0
%409 = shufflevector <4 x i32> %408, <4 x i32> poison, <4 x i32> zeroinitializer
%410 = getelementptr inbounds i16, i16* %199, i64 -3
br label %411
411: ; preds = %411, %401
%412 = phi i64 [ 0, %401 ], [ %444, %411 ]
%413 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %412
%414 = bitcast i32* %413 to <4 x i32>*
%415 = load <4 x i32>, <4 x i32>* %414
%416 = sub nsw i64 %148, %412
%417 = getelementptr inbounds i16, i16* %410, i64 %416
%418 = bitcast i16* %417 to <4 x i16>*
%419 = load <4 x i16>, <4 x i16>* %418
%420 = shufflevector <4 x i16> %419, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%421 = sext <4 x i16> %420 to <4 x i32>
%422 = mul nsw <4 x i32> %403, %421
%423 = mul nsw <4 x i32> %405, %421
%424 = ashr <4 x i32> %423, <i32 16, i32 16, i32 16, i32 16>
%425 = add <4 x i32> %422, %415
%426 = add <4 x i32> %425, %424
%427 = bitcast i32* %413 to <4 x i32>*
store <4 x i32> %426, <4 x i32>* %427
%428 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %412
%429 = bitcast i32* %428 to <4 x i32>*
%430 = load <4 x i32>, <4 x i32>* %429
%431 = add i64 %184, %412
%432 = shl i64 %431, 32
%433 = ashr exact i64 %432, 32
%434 = getelementptr inbounds i16, i16* %199, i64 %433
%435 = bitcast i16* %434 to <4 x i16>*
%436 = load <4 x i16>, <4 x i16>* %435
%437 = sext <4 x i16> %436 to <4 x i32>
%438 = mul nsw <4 x i32> %407, %437
%439 = mul nsw <4 x i32> %409, %437
%440 = ashr <4 x i32> %439, <i32 16, i32 16, i32 16, i32 16>
%441 = add <4 x i32> %438, %430
%442 = add <4 x i32> %441, %440
%443 = bitcast i32* %428 to <4 x i32>*
store <4 x i32> %442, <4 x i32>* %443
%444 = add nuw i64 %412, 4
%445 = icmp eq i64 %444, %194
br i1 %445, label %446, label %411
446: ; preds = %411
br i1 %195, label %477, label %447
447: ; preds = %389, %446
%448 = phi i64 [ 0, %389 ], [ %194, %446 ]
br label %449
449: ; preds = %447, %449
%450 = phi i64 [ %475, %449 ], [ %448, %447 ]
%451 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %450
%452 = load i32, i32* %451
%453 = sub nsw i64 %148, %450
%454 = getelementptr inbounds i16, i16* %199, i64 %453
%455 = load i16, i16* %454
%456 = sext i16 %455 to i32
%457 = mul nsw i32 %396, %456
%458 = mul nsw i32 %397, %456
%459 = ashr i32 %458, 16
%460 = add i32 %457, %452
%461 = add i32 %460, %459
store i32 %461, i32* %451
%462 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %450
%463 = load i32, i32* %462
%464 = add i64 %184, %450
%465 = shl i64 %464, 32
%466 = ashr exact i64 %465, 32
%467 = getelementptr inbounds i16, i16* %199, i64 %466
%468 = load i16, i16* %467
%469 = sext i16 %468 to i32
%470 = mul nsw i32 %398, %469
%471 = mul nsw i32 %399, %469
%472 = ashr i32 %471, 16
%473 = add i32 %470, %463
%474 = add i32 %473, %472
store i32 %474, i32* %462
%475 = add nuw nsw i64 %450, 1
%476 = icmp eq i64 %475, %149
br i1 %476, label %477, label %449
477: ; preds = %449, %446
%478 = add nuw nsw i64 %197, 1
%479 = icmp eq i64 %478, %138
br i1 %479, label %751, label %196
480: ; preds = %157, %748
%481 = phi i64 [ 0, %157 ], [ %749, %748 ]
%482 = mul nsw i64 %481, %135
%483 = getelementptr inbounds i16, i16* %3, i64 %482
%484 = getelementptr inbounds i16, i16* %483, i64 %148
%485 = load i16, i16* %484
%486 = sext i16 %485 to i32
%487 = shl i32 %486, %158
%488 = getelementptr inbounds i16, i16* %483, i64 %160
%489 = load i16, i16* %488
%490 = sext i16 %489 to i32
%491 = shl i32 %490, %158
%492 = shl i32 %486, 17
%493 = shl i32 %490, 17
br i1 %161, label %626, label %494
494: ; preds = %480
br i1 %164, label %588, label %495
495: ; preds = %494
%496 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %493, i64 0
%497 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %492, i64 0
%498 = insertelement <4 x i32> poison, i32 %487, i64 0
%499 = shufflevector <4 x i32> %498, <4 x i32> poison, <4 x i32> zeroinitializer
%500 = insertelement <4 x i32> poison, i32 %487, i64 0
%501 = shufflevector <4 x i32> %500, <4 x i32> poison, <4 x i32> zeroinitializer
%502 = insertelement <4 x i32> poison, i32 %491, i64 0
%503 = shufflevector <4 x i32> %502, <4 x i32> poison, <4 x i32> zeroinitializer
%504 = insertelement <4 x i32> poison, i32 %491, i64 0
%505 = shufflevector <4 x i32> %504, <4 x i32> poison, <4 x i32> zeroinitializer
br label %506
506: ; preds = %506, %495
%507 = phi i64 [ 0, %495 ], [ %581, %506 ]
%508 = phi <4 x i32> [ %496, %495 ], [ %579, %506 ]
%509 = phi <4 x i32> [ zeroinitializer, %495 ], [ %580, %506 ]
%510 = phi <4 x i32> [ %497, %495 ], [ %575, %506 ]
%511 = phi <4 x i32> [ zeroinitializer, %495 ], [ %576, %506 ]
%512 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %507
%513 = bitcast i32* %512 to <4 x i32>*
%514 = load <4 x i32>, <4 x i32>* %513
%515 = getelementptr inbounds i32, i32* %512, i64 4
%516 = bitcast i32* %515 to <4 x i32>*
%517 = load <4 x i32>, <4 x i32>* %516
%518 = xor i64 %507, -1
%519 = add nsw i64 %148, %518
%520 = getelementptr inbounds i16, i16* %483, i64 %519
%521 = getelementptr inbounds i16, i16* %520, i64 -3
%522 = bitcast i16* %521 to <4 x i16>*
%523 = load <4 x i16>, <4 x i16>* %522
%524 = shufflevector <4 x i16> %523, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%525 = getelementptr inbounds i16, i16* %520, i64 -4
%526 = getelementptr inbounds i16, i16* %525, i64 -3
%527 = bitcast i16* %526 to <4 x i16>*
%528 = load <4 x i16>, <4 x i16>* %527
%529 = shufflevector <4 x i16> %528, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%530 = sext <4 x i16> %524 to <4 x i32>
%531 = sext <4 x i16> %529 to <4 x i32>
%532 = mul <4 x i32> %499, %530
%533 = mul <4 x i32> %501, %531
%534 = sub <4 x i32> %514, %532
%535 = sub <4 x i32> %517, %533
%536 = bitcast i32* %512 to <4 x i32>*
store <4 x i32> %534, <4 x i32>* %536
%537 = bitcast i32* %515 to <4 x i32>*
store <4 x i32> %535, <4 x i32>* %537
%538 = getelementptr inbounds [16 x i32], [16 x i32]* %12, i64 0, i64 %507
%539 = bitcast i32* %538 to <4 x i32>*
%540 = load <4 x i32>, <4 x i32>* %539
%541 = getelementptr inbounds i32, i32* %538, i64 4
%542 = bitcast i32* %541 to <4 x i32>*
%543 = load <4 x i32>, <4 x i32>* %542
%544 = shl i64 %507, 32
%545 = ashr exact i64 %544, 32
%546 = add nsw i64 %545, %159
%547 = getelementptr inbounds i16, i16* %483, i64 %546
%548 = bitcast i16* %547 to <4 x i16>*
%549 = load <4 x i16>, <4 x i16>* %548
%550 = getelementptr inbounds i16, i16* %547, i64 4
%551 = bitcast i16* %550 to <4 x i16>*
%552 = load <4 x i16>, <4 x i16>* %551
%553 = sext <4 x i16> %549 to <4 x i32>
%554 = sext <4 x i16> %552 to <4 x i32>
%555 = mul <4 x i32> %503, %553
%556 = mul <4 x i32> %505, %554
%557 = sub <4 x i32> %540, %555
%558 = sub <4 x i32> %543, %556
%559 = bitcast i32* %538 to <4 x i32>*
store <4 x i32> %557, <4 x i32>* %559
%560 = bitcast i32* %541 to <4 x i32>*
store <4 x i32> %558, <4 x i32>* %560
%561 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %507
%562 = bitcast i32* %561 to <4 x i32>*
%563 = load <4 x i32>, <4 x i32>* %562
%564 = getelementptr inbounds i32, i32* %561, i64 4
%565 = bitcast i32* %564 to <4 x i32>*
%566 = load <4 x i32>, <4 x i32>* %565
%567 = ashr <4 x i32> %563, <i32 6, i32 6, i32 6, i32 6>
%568 = ashr <4 x i32> %566, <i32 6, i32 6, i32 6, i32 6>
%569 = add nsw <4 x i32> %567, <i32 1, i32 1, i32 1, i32 1>
%570 = add nsw <4 x i32> %568, <i32 1, i32 1, i32 1, i32 1>
%571 = ashr <4 x i32> %569, <i32 1, i32 1, i32 1, i32 1>
%572 = ashr <4 x i32> %570, <i32 1, i32 1, i32 1, i32 1>
%573 = mul nsw <4 x i32> %571, %530
%574 = mul nsw <4 x i32> %572, %531
%575 = add <4 x i32> %573, %510
%576 = add <4 x i32> %574, %511
%577 = mul nsw <4 x i32> %571, %553
%578 = mul nsw <4 x i32> %572, %554
%579 = add <4 x i32> %577, %508
%580 = add <4 x i32> %578, %509
%581 = add nuw i64 %507, 8
%582 = icmp eq i64 %581, %165
br i1 %582, label %583, label %506
583: ; preds = %506
%584 = add <4 x i32> %576, %575
%585 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %584)
%586 = add <4 x i32> %580, %579
%587 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %586)
br i1 %166, label %626, label %588
588: ; preds = %494, %583
%589 = phi i64 [ 0, %494 ], [ %165, %583 ]
%590 = phi i32 [ %493, %494 ], [ %587, %583 ]
%591 = phi i32 [ %492, %494 ], [ %585, %583 ]
br label %592
592: ; preds = %588, %592
%593 = phi i64 [ %624, %592 ], [ %589, %588 ]
%594 = phi i32 [ %623, %592 ], [ %590, %588 ]
%595 = phi i32 [ %621, %592 ], [ %591, %588 ]
%596 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %593
%597 = load i32, i32* %596
%598 = xor i64 %593, -1
%599 = add nsw i64 %148, %598
%600 = getelementptr inbounds i16, i16* %483, i64 %599
%601 = load i16, i16* %600
%602 = sext i16 %601 to i32
%603 = mul i32 %487, %602
%604 = sub i32 %597, %603
store i32 %604, i32* %596
%605 = getelementptr inbounds [16 x i32], [16 x i32]* %12, i64 0, i64 %593
%606 = load i32, i32* %605
%607 = shl i64 %593, 32
%608 = ashr exact i64 %607, 32
%609 = add nsw i64 %608, %159
%610 = getelementptr inbounds i16, i16* %483, i64 %609
%611 = load i16, i16* %610
%612 = sext i16 %611 to i32
%613 = mul i32 %491, %612
%614 = sub i32 %606, %613
store i32 %614, i32* %605
%615 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %593
%616 = load i32, i32* %615
%617 = ashr i32 %616, 6
%618 = add nsw i32 %617, 1
%619 = ashr i32 %618, 1
%620 = mul nsw i32 %619, %602
%621 = add nsw i32 %620, %595
%622 = mul nsw i32 %619, %612
%623 = add nsw i32 %622, %594
%624 = add nuw nsw i64 %593, 1
%625 = icmp eq i64 %624, %148
br i1 %625, label %626, label %592
626: ; preds = %592, %583, %480
%627 = phi i32 [ %492, %480 ], [ %585, %583 ], [ %621, %592 ]
%628 = phi i32 [ %493, %480 ], [ %587, %583 ], [ %623, %592 ]
%629 = sub nsw i32 0, %627
%630 = sub nsw i32 0, %628
%631 = ashr i32 %629, 16
%632 = and i32 %629, 65535
%633 = ashr i32 %630, 16
%634 = and i32 %630, 65535
%635 = select i1 %167, i1 true, i1 %172
br i1 %635, label %702, label %636
636: ; preds = %626
%637 = insertelement <4 x i32> poison, i32 %631, i64 0
%638 = shufflevector <4 x i32> %637, <4 x i32> poison, <4 x i32> zeroinitializer
%639 = insertelement <4 x i32> poison, i32 %632, i64 0
%640 = shufflevector <4 x i32> %639, <4 x i32> poison, <4 x i32> zeroinitializer
%641 = insertelement <4 x i32> poison, i32 %629, i64 0
%642 = shufflevector <4 x i32> %641, <4 x i32> poison, <4 x i32> zeroinitializer
%643 = insertelement <4 x i32> poison, i32 %633, i64 0
%644 = shufflevector <4 x i32> %643, <4 x i32> poison, <4 x i32> zeroinitializer
%645 = insertelement <4 x i32> poison, i32 %634, i64 0
%646 = shufflevector <4 x i32> %645, <4 x i32> poison, <4 x i32> zeroinitializer
%647 = insertelement <4 x i32> poison, i32 %630, i64 0
%648 = shufflevector <4 x i32> %647, <4 x i32> poison, <4 x i32> zeroinitializer
%649 = getelementptr inbounds i16, i16* %483, i64 -3
br label %650
650: ; preds = %650, %636
%651 = phi i64 [ 0, %636 ], [ %699, %650 ]
%652 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %651
%653 = bitcast i32* %652 to <4 x i32>*
%654 = load <4 x i32>, <4 x i32>* %653
%655 = sub nsw i64 %148, %651
%656 = getelementptr inbounds i16, i16* %649, i64 %655
%657 = bitcast i16* %656 to <4 x i16>*
%658 = load <4 x i16>, <4 x i16>* %657
%659 = shufflevector <4 x i16> %658, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%660 = sext <4 x i16> %659 to <4 x i32>
%661 = shl <4 x i32> %660, %175
%662 = shl <4 x i32> %661, <i32 16, i32 16, i32 16, i32 16>
%663 = ashr exact <4 x i32> %662, <i32 16, i32 16, i32 16, i32 16>
%664 = mul nsw <4 x i32> %663, %638
%665 = mul nsw <4 x i32> %663, %640
%666 = ashr <4 x i32> %665, <i32 16, i32 16, i32 16, i32 16>
%667 = ashr <4 x i32> %661, <i32 15, i32 15, i32 15, i32 15>
%668 = add nsw <4 x i32> %667, <i32 1, i32 1, i32 1, i32 1>
%669 = ashr <4 x i32> %668, <i32 1, i32 1, i32 1, i32 1>
%670 = mul nsw <4 x i32> %669, %642
%671 = add <4 x i32> %664, %654
%672 = add <4 x i32> %671, %666
%673 = add <4 x i32> %672, %670
%674 = bitcast i32* %652 to <4 x i32>*
store <4 x i32> %673, <4 x i32>* %674
%675 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %651
%676 = bitcast i32* %675 to <4 x i32>*
%677 = load <4 x i32>, <4 x i32>* %676
%678 = add i64 %163, %651
%679 = shl i64 %678, 32
%680 = ashr exact i64 %679, 32
%681 = getelementptr inbounds i16, i16* %483, i64 %680
%682 = bitcast i16* %681 to <4 x i16>*
%683 = load <4 x i16>, <4 x i16>* %682
%684 = sext <4 x i16> %683 to <4 x i32>
%685 = shl <4 x i32> %684, %175
%686 = shl <4 x i32> %685, <i32 16, i32 16, i32 16, i32 16>
%687 = ashr exact <4 x i32> %686, <i32 16, i32 16, i32 16, i32 16>
%688 = mul nsw <4 x i32> %687, %644
%689 = mul nsw <4 x i32> %687, %646
%690 = ashr <4 x i32> %689, <i32 16, i32 16, i32 16, i32 16>
%691 = ashr <4 x i32> %685, <i32 15, i32 15, i32 15, i32 15>
%692 = add nsw <4 x i32> %691, <i32 1, i32 1, i32 1, i32 1>
%693 = ashr <4 x i32> %692, <i32 1, i32 1, i32 1, i32 1>
%694 = mul nsw <4 x i32> %693, %648
%695 = add <4 x i32> %688, %677
%696 = add <4 x i32> %695, %690
%697 = add <4 x i32> %696, %694
%698 = bitcast i32* %675 to <4 x i32>*
store <4 x i32> %697, <4 x i32>* %698
%699 = add nuw i64 %651, 4
%700 = icmp eq i64 %699, %173
br i1 %700, label %701, label %650
701: ; preds = %650
br i1 %176, label %748, label %702
702: ; preds = %626, %701
%703 = phi i64 [ 0, %626 ], [ %173, %701 ]
br label %704
704: ; preds = %702, %704
%705 = phi i64 [ %746, %704 ], [ %703, %702 ]
%706 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %705
%707 = load i32, i32* %706
%708 = sub nsw i64 %148, %705
%709 = getelementptr inbounds i16, i16* %483, i64 %708
%710 = load i16, i16* %709
%711 = sext i16 %710 to i32
%712 = shl i32 %711, %162
%713 = shl i32 %712, 16
%714 = ashr exact i32 %713, 16
%715 = mul nsw i32 %714, %631
%716 = mul nsw i32 %714, %632
%717 = ashr i32 %716, 16
%718 = ashr i32 %712, 15
%719 = add nsw i32 %718, 1
%720 = ashr i32 %719, 1
%721 = mul nsw i32 %720, %629
%722 = add i32 %715, %707
%723 = add i32 %722, %717
%724 = add i32 %723, %721
store i32 %724, i32* %706
%725 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %705
%726 = load i32, i32* %725
%727 = add i64 %163, %705
%728 = shl i64 %727, 32
%729 = ashr exact i64 %728, 32
%730 = getelementptr inbounds i16, i16* %483, i64 %729
%731 = load i16, i16* %730
%732 = sext i16 %731 to i32
%733 = shl i32 %732, %162
%734 = shl i32 %733, 16
%735 = ashr exact i32 %734, 16
%736 = mul nsw i32 %735, %633
%737 = mul nsw i32 %735, %634
%738 = ashr i32 %737, 16
%739 = ashr i32 %733, 15
%740 = add nsw i32 %739, 1
%741 = ashr i32 %740, 1
%742 = mul nsw i32 %741, %630
%743 = add i32 %736, %726
%744 = add i32 %743, %738
%745 = add i32 %744, %742
store i32 %745, i32* %725
%746 = add nuw nsw i64 %705, 1
%747 = icmp eq i64 %746, %149
br i1 %747, label %748, label %704
748: ; preds = %704, %701
%749 = add nuw nsw i64 %481, 1
%750 = icmp eq i64 %749, %137
br i1 %750, label %751, label %480
751: ; preds = %748, %477, %156, %177
%752 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %148
%753 = load i32, i32* %752
%754 = getelementptr inbounds [16 x i32], [16 x i32]* %12, i64 0, i64 %148
%755 = load i32, i32* %754
%756 = load i32, i32* %129
%757 = load i32, i32* %128
%758 = add nsw i32 %757, %756
%759 = icmp eq i64 %148, 0
br i1 %759, label %815, label %760
760: ; preds = %751, %760
%761 = phi i64 [ %802, %760 ], [ 0, %751 ]
%762 = phi i32 [ %793, %760 ], [ %755, %751 ]
%763 = phi i32 [ %785, %760 ], [ %753, %751 ]
%764 = phi i32 [ %813, %760 ], [ %758, %751 ]
%765 = phi i32 [ %801, %760 ], [ 0, %751 ]
%766 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %761
%767 = load i32, i32* %766
%768 = call i32 @llvm.abs.i32(i32 %767, i1 true)
%769 = call i32 (i32, ...) bitcast (i32 (...)* @SKP_Silk_CLZ32 to i32 (i32, ...)*)(i32 %768)
%770 = icmp slt i32 %769, 9
%771 = select i1 %770, i32 %769, i32 9
%772 = add nsw i32 %771, -1
%773 = shl i32 %767, %772
%774 = sub nsw i64 %148, %761
%775 = add nsw i64 %774, -1
%776 = getelementptr inbounds [16 x i32], [16 x i32]* %12, i64 0, i64 %775
%777 = load i32, i32* %776
%778 = sext i32 %777 to i64
%779 = sext i32 %773 to i64
%780 = mul nsw i64 %779, %778
%781 = lshr i64 %780, 32
%782 = trunc i64 %781 to i32
%783 = sub i32 9, %771
%784 = shl i32 %782, %783
%785 = add nsw i32 %784, %763
%786 = getelementptr inbounds [16 x i32], [16 x i32]* %11, i64 0, i64 %775
%787 = load i32, i32* %786
%788 = sext i32 %787 to i64
%789 = mul nsw i64 %779, %788
%790 = lshr i64 %789, 32
%791 = trunc i64 %790 to i32
%792 = shl i32 %791, %783
%793 = add nsw i32 %792, %762
%794 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %774
%795 = load i32, i32* %794
%796 = sext i32 %795 to i64
%797 = mul nsw i64 %779, %796
%798 = lshr i64 %797, 32
%799 = trunc i64 %798 to i32
%800 = shl i32 %799, %783
%801 = add nsw i32 %800, %765
%802 = add nuw nsw i64 %761, 1
%803 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %802
%804 = load i32, i32* %803
%805 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %802
%806 = load i32, i32* %805
%807 = add nsw i32 %806, %804
%808 = sext i32 %807 to i64
%809 = mul nsw i64 %808, %779
%810 = lshr i64 %809, 32
%811 = trunc i64 %810 to i32
%812 = shl i32 %811, %783
%813 = add nsw i32 %812, %764
%814 = icmp eq i64 %802, %148
br i1 %814, label %815, label %760
815: ; preds = %760, %751
%816 = phi i32 [ 0, %751 ], [ %801, %760 ]
%817 = phi i32 [ %758, %751 ], [ %813, %760 ]
%818 = phi i32 [ %753, %751 ], [ %785, %760 ]
%819 = phi i32 [ %755, %751 ], [ %793, %760 ]
%820 = add nuw nsw i64 %148, 1
%821 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %820
store i32 %818, i32* %821
%822 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %820
store i32 %819, i32* %822
%823 = add nsw i32 %819, %816
%824 = mul i32 %823, -2
%825 = call i32 @llvm.abs.i32(i32 %824, i1 true)
%826 = icmp slt i32 %825, %817
br i1 %826, label %827, label %835
827: ; preds = %815
%828 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @SKP_DIV32_varQ to i32 (i32, i32, i32, ...)*)(i32 %824, i32 %817, i32 31)
br i1 %759, label %829, label %831
829: ; preds = %827
%830 = sext i32 %828 to i64
br label %865
831: ; preds = %827
%832 = lshr i64 %820, 1
%833 = sext i32 %828 to i64
%834 = and i64 %832, 2147483647
br label %843
835: ; preds = %815
%836 = trunc i64 %148 to i32
%837 = and i64 %148, 4294967295
%838 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %837
%839 = bitcast i32* %838 to i8*
%840 = sub nsw i32 %7, %836
%841 = sext i32 %840 to i64
%842 = shl nsw i64 %841, 2
br label %927
843: ; preds = %831, %843
%844 = phi i64 [ 0, %831 ], [ %863, %843 ]
%845 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %844
%846 = load i32, i32* %845
%847 = xor i64 %844, -1
%848 = add nsw i64 %148, %847
%849 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %848
%850 = load i32, i32* %849
%851 = sext i32 %850 to i64
%852 = mul nsw i64 %851, %833
%853 = lshr i64 %852, 31
%854 = trunc i64 %853 to i32
%855 = and i32 %854, -2
%856 = add nsw i32 %855, %846
store i32 %856, i32* %845
%857 = sext i32 %846 to i64
%858 = mul nsw i64 %857, %833
%859 = lshr i64 %858, 31
%860 = trunc i64 %859 to i32
%861 = and i32 %860, -2
%862 = add nsw i32 %861, %850
store i32 %862, i32* %849
%863 = add nuw nsw i64 %844, 1
%864 = icmp ult i64 %863, %834
br i1 %864, label %843, label %865
865: ; preds = %843, %829
%866 = phi i64 [ %830, %829 ], [ %833, %843 ]
%867 = ashr i32 %828, 7
%868 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %148
store i32 %867, i32* %868
%869 = icmp ult i64 %150, 4
br i1 %869, label %904, label %870
870: ; preds = %865
%871 = and i64 %150, 9223372036854775804
%872 = insertelement <4 x i64> poison, i64 %866, i64 0
%873 = shufflevector <4 x i64> %872, <4 x i64> poison, <4 x i32> zeroinitializer
br label %874
874: ; preds = %874, %870
%875 = phi i64 [ 0, %870 ], [ %900, %874 ]
%876 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %875
%877 = bitcast i32* %876 to <4 x i32>*
%878 = load <4 x i32>, <4 x i32>* %877
%879 = sub nsw i64 %820, %875
%880 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %879
%881 = getelementptr inbounds i32, i32* %880, i64 -3
%882 = bitcast i32* %881 to <4 x i32>*
%883 = load <4 x i32>, <4 x i32>* %882
%884 = shufflevector <4 x i32> %883, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%885 = sext <4 x i32> %884 to <4 x i64>
%886 = mul nsw <4 x i64> %873, %885
%887 = lshr <4 x i64> %886, <i64 31, i64 31, i64 31, i64 31>
%888 = trunc <4 x i64> %887 to <4 x i32>
%889 = and <4 x i32> %888, <i32 -2, i32 -2, i32 -2, i32 -2>
%890 = add nsw <4 x i32> %889, %878
%891 = bitcast i32* %876 to <4 x i32>*
store <4 x i32> %890, <4 x i32>* %891
%892 = sext <4 x i32> %878 to <4 x i64>
%893 = mul nsw <4 x i64> %873, %892
%894 = lshr <4 x i64> %893, <i64 31, i64 31, i64 31, i64 31>
%895 = trunc <4 x i64> %894 to <4 x i32>
%896 = and <4 x i32> %895, <i32 -2, i32 -2, i32 -2, i32 -2>
%897 = add nsw <4 x i32> %896, %884
%898 = shufflevector <4 x i32> %897, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%899 = bitcast i32* %881 to <4 x i32>*
store <4 x i32> %898, <4 x i32>* %899
%900 = add nuw i64 %875, 4
%901 = icmp eq i64 %900, %871
br i1 %901, label %902, label %874
902: ; preds = %874
%903 = icmp eq i64 %150, %871
br i1 %903, label %140, label %904
904: ; preds = %865, %902
%905 = phi i64 [ 0, %865 ], [ %871, %902 ]
br label %906
906: ; preds = %904, %906
%907 = phi i64 [ %925, %906 ], [ %905, %904 ]
%908 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %907
%909 = load i32, i32* %908
%910 = sub nsw i64 %820, %907
%911 = getelementptr inbounds [17 x i32], [17 x i32]* %15, i64 0, i64 %910
%912 = load i32, i32* %911
%913 = sext i32 %912 to i64
%914 = mul nsw i64 %866, %913
%915 = lshr i64 %914, 31
%916 = trunc i64 %915 to i32
%917 = and i32 %916, -2
%918 = add nsw i32 %917, %909
store i32 %918, i32* %908
%919 = sext i32 %909 to i64
%920 = mul nsw i64 %866, %919
%921 = lshr i64 %920, 31
%922 = trunc i64 %921 to i32
%923 = and i32 %922, -2
%924 = add nsw i32 %923, %912
store i32 %924, i32* %911
%925 = add nuw nsw i64 %907, 1
%926 = icmp eq i64 %925, %150
br i1 %926, label %140, label %906
927: ; preds = %140, %835
%928 = load i32, i32* %128
br i1 %130, label %929, label %1023
929: ; preds = %927
%930 = zext i32 %7 to i64
%931 = icmp ult i32 %7, 4
br i1 %931, label %981, label %932
932: ; preds = %929
%933 = and i64 %136, 4294967292
%934 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %928, i64 0
br label %935
935: ; preds = %935, %932
%936 = phi i64 [ 0, %932 ], [ %975, %935 ]
%937 = phi <4 x i32> [ <i32 65536, i32 0, i32 0, i32 0>, %932 ], [ %971, %935 ]
%938 = phi <4 x i32> [ %934, %932 ], [ %962, %935 ]
%939 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %936
%940 = bitcast i32* %939 to <4 x i32>*
%941 = load <4 x i32>, <4 x i32>* %940
%942 = ashr <4 x i32> %941, <i32 7, i32 7, i32 7, i32 7>
%943 = add nsw <4 x i32> %942, <i32 1, i32 1, i32 1, i32 1>
%944 = ashr <4 x i32> %943, <i32 1, i32 1, i32 1, i32 1>
%945 = or i64 %936, 1
%946 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %945
%947 = bitcast i32* %946 to <4 x i32>*
%948 = load <4 x i32>, <4 x i32>* %947
%949 = ashr <4 x i32> %948, <i32 16, i32 16, i32 16, i32 16>
%950 = shl <4 x i32> %944, <i32 16, i32 16, i32 16, i32 16>
%951 = ashr exact <4 x i32> %950, <i32 16, i32 16, i32 16, i32 16>
%952 = mul nsw <4 x i32> %951, %949
%953 = and <4 x i32> %948, <i32 65535, i32 65535, i32 65535, i32 65535>
%954 = mul nsw <4 x i32> %951, %953
%955 = ashr <4 x i32> %954, <i32 16, i32 16, i32 16, i32 16>
%956 = ashr <4 x i32> %943, <i32 16, i32 16, i32 16, i32 16>
%957 = add nsw <4 x i32> %956, <i32 1, i32 1, i32 1, i32 1>
%958 = ashr <4 x i32> %957, <i32 1, i32 1, i32 1, i32 1>
%959 = mul nsw <4 x i32> %958, %948
%960 = add <4 x i32> %952, %938
%961 = add <4 x i32> %960, %959
%962 = add <4 x i32> %961, %955
%963 = ashr <4 x i32> %943, <i32 17, i32 17, i32 17, i32 17>
%964 = mul nsw <4 x i32> %951, %963
%965 = and <4 x i32> %944, <i32 65535, i32 65535, i32 65535, i32 65535>
%966 = mul nsw <4 x i32> %951, %965
%967 = ashr <4 x i32> %966, <i32 16, i32 16, i32 16, i32 16>
%968 = mul nsw <4 x i32> %958, %944
%969 = add <4 x i32> %964, %937
%970 = add <4 x i32> %969, %968
%971 = add <4 x i32> %970, %967
%972 = sub nsw <4 x i32> zeroinitializer, %944
%973 = getelementptr inbounds i32, i32* %2, i64 %936
%974 = bitcast i32* %973 to <4 x i32>*
store <4 x i32> %972, <4 x i32>* %974
%975 = add nuw i64 %936, 4
%976 = icmp eq i64 %975, %933
br i1 %976, label %977, label %935
977: ; preds = %935
%978 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %962)
%979 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %971)
%980 = icmp eq i64 %933, %136
br i1 %980, label %1023, label %981
981: ; preds = %929, %977
%982 = phi i64 [ 0, %929 ], [ %933, %977 ]
%983 = phi i32 [ 65536, %929 ], [ %979, %977 ]
%984 = phi i32 [ %928, %929 ], [ %978, %977 ]
br label %985
985: ; preds = %981, %985
%986 = phi i64 [ %994, %985 ], [ %982, %981 ]
%987 = phi i32 [ %1019, %985 ], [ %983, %981 ]
%988 = phi i32 [ %1010, %985 ], [ %984, %981 ]
%989 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %986
%990 = load i32, i32* %989
%991 = ashr i32 %990, 7
%992 = add nsw i32 %991, 1
%993 = ashr i32 %992, 1
%994 = add nuw nsw i64 %986, 1
%995 = getelementptr inbounds [17 x i32], [17 x i32]* %14, i64 0, i64 %994
%996 = load i32, i32* %995
%997 = ashr i32 %996, 16
%998 = shl i32 %993, 16
%999 = ashr exact i32 %998, 16
%1000 = mul nsw i32 %999, %997
%1001 = and i32 %996, 65535
%1002 = mul nsw i32 %999, %1001
%1003 = ashr i32 %1002, 16
%1004 = ashr i32 %992, 16
%1005 = add nsw i32 %1004, 1
%1006 = ashr i32 %1005, 1
%1007 = mul nsw i32 %1006, %996
%1008 = add i32 %1000, %988
%1009 = add i32 %1008, %1007
%1010 = add i32 %1009, %1003
%1011 = ashr i32 %992, 17
%1012 = mul nsw i32 %999, %1011
%1013 = and i32 %993, 65535
%1014 = mul nsw i32 %999, %1013
%1015 = ashr i32 %1014, 16
%1016 = mul nsw i32 %1006, %993
%1017 = add i32 %1012, %987
%1018 = add i32 %1017, %1016
%1019 = add i32 %1018, %1015
%1020 = sub nsw i32 0, %993
%1021 = getelementptr inbounds i32, i32* %2, i64 %986
store i32 %1020, i32* %1021
%1022 = icmp eq i64 %994, %930
br i1 %1022, label %1023, label %985
1023: ; preds = %985, %977, %131, %927
%1024 = phi i32 [ %928, %927 ], [ %132, %131 ], [ %978, %977 ], [ %1010, %985 ]
%1025 = phi i32 [ 65536, %927 ], [ 65536, %131 ], [ %979, %977 ], [ %1019, %985 ]
%1026 = load i32, i32* %10
%1027 = sext i32 %1026 to i64
%1028 = mul nsw i64 %1027, %121
%1029 = lshr i64 %1028, 32
%1030 = trunc i64 %1029 to i32
%1031 = ashr i32 %1030, 16
%1032 = sub nsw i32 0, %1025
%1033 = shl i32 %1032, 16
%1034 = ashr exact i32 %1033, 16
%1035 = mul nsw i32 %1031, %1034
%1036 = and i32 %1030, 65535
%1037 = mul nsw i32 %1036, %1034
%1038 = ashr i32 %1037, 16
%1039 = ashr i32 %1032, 15
%1040 = add nsw i32 %1039, 1
%1041 = ashr i32 %1040, 1
%1042 = mul nsw i32 %1041, %1030
%1043 = add i32 %1042, %1024
%1044 = add i32 %1043, %1035
%1045 = add i32 %1044, %1038
store i32 %1045, i32* %0
%1046 = load i32, i32* %9
%1047 = sub nsw i32 0, %1046
store i32 %1047, i32* %1
ret void
}