void WebRtcIsac_NormLatticeFilterAr(int orderCoef, float *stateF, float *stateG,
                                    double *lat_in, double *lo_filt_coef,
                                    float *lat_out) {
  int n, k, i, u, temp1;
  int ord_1 = orderCoef + 1;
  float sth[12];
  float cth[12];
  double a[12 + 1];
  float ARf[12 + 1][(80 / 2)], ARg[12 + 1][(80 / 2)];
  float gain1, inv_gain1;
  for (u = 0; u < 6; u++) {
    temp1 = u * ord_1;
    a[0] = 1;
    memcpy(a + 1, lo_filt_coef + temp1 + 1, sizeof(double) * (ord_1 - 1));
    WebRtcIsac_Dir2Lat(a, orderCoef, sth, cth);
    gain1 = (float)lo_filt_coef[temp1];
    for (k = 0; k < orderCoef; k++) {
      gain1 = cth[k] * gain1;
    }
    inv_gain1 = 1 / gain1;
    for (i = 0; i < (80 / 2); i++) {
      ARf[orderCoef][i] = (float)lat_in[i + u * (80 / 2)] * inv_gain1;
    }
    for (i = orderCoef - 1; i >= 0; i--) {
      ARf[i][0] = cth[i] * ARf[i + 1][0] - sth[i] * stateG[i];
      ARg[i + 1][0] = sth[i] * ARf[i + 1][0] + cth[i] * stateG[i];
    }
    ARg[0][0] = ARf[0][0];
    for (n = 0; n < ((80 / 2) - 1); n++) {
      for (k = orderCoef - 1; k >= 0; k--) {
        ARf[k][n + 1] = cth[k] * ARf[k + 1][n + 1] - sth[k] * ARg[k][n];
        ARg[k + 1][n + 1] = sth[k] * ARf[k + 1][n + 1] + cth[k] * ARg[k][n];
      }
      ARg[0][n + 1] = ARf[0][n + 1];
    }
    memcpy(lat_out + u * (80 / 2), &(ARf[0][0]), sizeof(float) * (80 / 2));
    for (i = 0; i < ord_1; i++) {
      stateF[i] = ARf[i][(80 / 2) - 1];
      stateG[i] = ARg[i][(80 / 2) - 1];
    }
  }
  return;
}


x86 assembly (clang, -O0):
<WebRtcIsac_NormLatticeFilterAr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1170,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    15c6 <WebRtcIsac_NormLatticeFilterAr+0x4a6>
mov    -0x40(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  0xe92(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
lea    -0x120(%rbp),%rdi
add    $0x8,%rdi
mov    -0x28(%rbp),%rsi
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
add    $0x8,%rsi
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
shl    $0x3,%rdx
call   1030 <memcpy@plt>
lea    -0x120(%rbp),%rdi
mov    -0x4(%rbp),%esi
lea    -0x80(%rbp),%rdx
lea    -0xb0(%rbp),%rcx
mov    $0x0,%al
call   1040 <WebRtcIsac_Dir2Lat@plt>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1164(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1219 <WebRtcIsac_NormLatticeFilterAr+0xf9>
movslq -0x38(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mulss  -0x1164(%rbp),%xmm0
ff
movss  %xmm0,-0x1164(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11e2 <WebRtcIsac_NormLatticeFilterAr+0xc2>
movss  0xde7(%rip),%xmm0
divss  -0x1164(%rbp),%xmm0
ff
movss  %xmm0,-0x1168(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
cmpl   $0x28,-0x3c(%rbp)
jge    128f <WebRtcIsac_NormLatticeFilterAr+0x16f>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x28,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  -0x1168(%rbp),%xmm0
ff
movslq -0x4(%rbp),%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1238 <WebRtcIsac_NormLatticeFilterAr+0x118>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1388 <WebRtcIsac_NormLatticeFilterAr+0x268>
movslq -0x3c(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  (%rax),%xmm2
movslq -0x3c(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x3c(%rbp),%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,(%rax)
movslq -0x3c(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm0
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  (%rax),%xmm2
movslq -0x3c(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm1
ff ff
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1160(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1298 <WebRtcIsac_NormLatticeFilterAr+0x178>
movss  -0x940(%rbp),%xmm0
ff
movss  %xmm0,-0x1160(%rbp)
ff
movl   $0x0,-0x34(%rbp)
cmpl   $0x27,-0x34(%rbp)
jge    151c <WebRtcIsac_NormLatticeFilterAr+0x3fc>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     14ec <WebRtcIsac_NormLatticeFilterAr+0x3cc>
movslq -0x38(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x38(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm1
movslq -0x38(%rbp),%rcx
lea    -0x1160(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x38(%rbp),%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x38(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm0
mov    -0x38(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x38(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm1
ff ff
movslq -0x38(%rbp),%rcx
lea    -0x1160(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1160(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    13b2 <WebRtcIsac_NormLatticeFilterAr+0x292>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x940(%rbp,%rax,4),%xmm0
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x1160(%rbp,%rax,4)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    139f <WebRtcIsac_NormLatticeFilterAr+0x27f>
mov    -0x30(%rbp),%rdi
imul   $0x28,-0x40(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x940(%rbp),%rsi
mov    $0xa0,%edx
call   1030 <memcpy@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15b3 <WebRtcIsac_NormLatticeFilterAr+0x493>
movslq -0x3c(%rbp),%rcx
lea    -0x940(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  0x9c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x3c(%rbp),%rcx
lea    -0x1160(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  0x9c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1545 <WebRtcIsac_NormLatticeFilterAr+0x425>
jmp    15b8 <WebRtcIsac_NormLatticeFilterAr+0x498>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1152 <WebRtcIsac_NormLatticeFilterAr+0x32>
add    $0x1170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<WebRtcIsac_NormLatticeFilterAr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x11a8,%rsp
mov    %r9,0xb8(%rsp)
mov    %r8,0xb0(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %rdx,%rbx
mov    %rsi,%r13
mov    %edi,%r12d
lea    0x1(%r12),%r14d
movslq %edi,%rcx
lea    0x0(,%rcx,8),%rax
mov    %rax,0xa0(%rsp)
lea    -0x1(%rcx),%eax
mov    %ecx,%edx
lea    (%rsi,%r14,4),%rdi
lea    (%rbx,%r14,4),%rsi
lea    -0x1(%rdx),%rbp
mov    %rbp,0x70(%rsp)
mov    %edx,%ebp
and    $0x7,%ebp
mov    %rbp,0x18(%rsp)
and    $0xfffffff8,%edx
mov    %rdx,0x58(%rsp)
lea    (%rcx,%rcx,4),%rcx
shl    $0x5,%rcx
cmp    %r13,%rsi
seta   %dl
add    %rsp,%rcx
add    $0x160,%rcx
mov    %rcx,0x98(%rsp)
cmp    %rbx,%rdi
seta   %cl
and    %dl,%cl
mov    %cl,0x7(%rsp)
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x50(%rsp)
mov    %r14,%rcx
neg    %rcx
mov    %rcx,0x60(%rsp)
lea    0x1(%rax),%r15
shl    $0x5,%rax
lea    (%rax,%rax,4),%rax
lea    (%rsp,%rax,1),%rcx
add    $0x160,%rcx
or     $0x4,%rcx
mov    %rcx,0x90(%rsp)
lea    0x0(,%r14,4),%rdx
and    $0xfffffffffffffff0,%rdx
movslq %r14d,%rcx
mov    %rcx,0x80(%rsp)
mov    %rax,0x68(%rsp)
add    %rsp,%rax
add    $0x980,%rax
mov    %rax,0x78(%rsp)
xor    %ebp,%ebp
mov    %r14,0x10(%rsp)
mov    %rdx,0x88(%rsp)
jmp    124e <WebRtcIsac_NormLatticeFilterAr+0x12e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    $0x6,%rbp
je     17cf <WebRtcIsac_NormLatticeFilterAr+0x6af>
mov    %rbp,0x8(%rsp)
imul   0x80(%rsp),%rbp
movabs $0x3ff0000000000000,%rax
mov    %rax,0xf0(%rsp)
mov    0xb0(%rsp),%r14
lea    (%r14,%rbp,8),%rsi
add    $0x8,%rsi
lea    0xf8(%rsp),%rdi
mov    0xa0(%rsp),%rdx
call   1030 <memcpy@plt>
lea    0xf0(%rsp),%rdi
mov    %r12d,%esi
lea    0xc0(%rsp),%rdx
lea    0x20(%rsp),%rcx
xor    %eax,%eax
call   1040 <WebRtcIsac_Dir2Lat@plt>
movsd  (%r14,%rbp,8),%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
test   %r12d,%r12d
jle    12e0 <WebRtcIsac_NormLatticeFilterAr+0x1c0>
cmpq   $0x7,0x70(%rsp)
jae    12f0 <WebRtcIsac_NormLatticeFilterAr+0x1d0>
xor    %eax,%eax
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%rdx
mov    0x8(%rsp),%rsi
jmp    1349 <WebRtcIsac_NormLatticeFilterAr+0x229>
nop
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rsi
jmp    136e <WebRtcIsac_NormLatticeFilterAr+0x24e>
nop
xor    %eax,%eax
mov    0x10(%rsp),%r14
mov    0x58(%rsp),%rcx
mov    0x18(%rsp),%rdx
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
mulss  0x20(%rsp,%rax,4),%xmm1
mulss  0x24(%rsp,%rax,4),%xmm1
mulss  0x28(%rsp,%rax,4),%xmm1
mulss  0x2c(%rsp,%rax,4),%xmm1
mulss  0x30(%rsp,%rax,4),%xmm1
mulss  0x34(%rsp,%rax,4),%xmm1
mulss  0x38(%rsp,%rax,4),%xmm1
mulss  0x3c(%rsp,%rax,4),%xmm1
add    $0x8,%rax
cmp    %rax,%rcx
jne    1310 <WebRtcIsac_NormLatticeFilterAr+0x1f0>
test   %rdx,%rdx
je     136e <WebRtcIsac_NormLatticeFilterAr+0x24e>
lea    (%rsp,%rax,4),%rax
add    $0x20,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mulss  (%rax,%rcx,4),%xmm1
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1360 <WebRtcIsac_NormLatticeFilterAr+0x240>
lea    0x0(,%rsi,8),%rax
lea    (%rax,%rax,4),%rax
movss  0xc7e(%rip),%xmm0
divss  %xmm1,%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0xa8(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
mov    0x98(%rsp),%rdx
movlps %xmm1,(%rdx)
movupd 0x10(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x8(%rdx)
movupd 0x20(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x10(%rdx)
movupd 0x30(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x18(%rdx)
movupd 0x40(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x20(%rdx)
movupd 0x50(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x28(%rdx)
movupd 0x60(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x30(%rdx)
movupd 0x70(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x38(%rdx)
movupd 0x80(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x40(%rdx)
movupd 0x90(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x48(%rdx)
movupd 0xa0(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x50(%rdx)
movupd 0xb0(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x58(%rdx)
movupd 0xc0(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x60(%rdx)
movupd 0xd0(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x68(%rdx)
movupd 0xe0(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x70(%rdx)
movupd 0xf0(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x78(%rdx)
movupd 0x100(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x80(%rdx)
movupd 0x110(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x88(%rdx)
movupd 0x120(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x90(%rdx)
movupd 0x130(%rcx,%rax,8),%xmm1
cvtpd2ps %xmm1,%xmm1
mulps  %xmm0,%xmm1
movlps %xmm1,0x98(%rdx)
test   %r12d,%r12d
jle    1588 <WebRtcIsac_NormLatticeFilterAr+0x468>
mov    0x68(%rsp),%rcx
mov    %r15,%rdx
nopl   0x0(%rax)
movss  0x1c(%rsp,%rdx,4),%xmm0
movss  0x200(%rsp,%rcx,1),%xmm1
movss  0xbc(%rsp,%rdx,4),%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm3
movaps %xmm0,%xmm4
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm3
mulss  %xmm1,%xmm4
subss  %xmm3,%xmm4
movss  %xmm4,0x160(%rsp,%rcx,1)
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0xa20(%rsp,%rcx,1)
add    $0xffffffffffffff60,%rcx
add    $0xffffffffffffffff,%rdx
jg     1530 <WebRtcIsac_NormLatticeFilterAr+0x410>
movss  0x160(%rsp),%xmm0
movss  %xmm0,0x980(%rsp)
mov    0x90(%rsp),%rcx
mov    0x78(%rsp),%rdx
xor    %esi,%esi
jmp    15d0 <WebRtcIsac_NormLatticeFilterAr+0x4b0>
nopl   0x0(%rax,%rax,1)
movss  0x160(%rsp,%rsi,4),%xmm0
movss  %xmm0,0x980(%rsp,%rsi,4)
add    $0x4,%rdx
add    $0x4,%rcx
cmp    $0x27,%rsi
je     1640 <WebRtcIsac_NormLatticeFilterAr+0x520>
add    $0x1,%rsi
test   %r12d,%r12d
jle    15b0 <WebRtcIsac_NormLatticeFilterAr+0x490>
xor    %edi,%edi
mov    %r15,%rbp
xchg   %ax,%ax
movss  0x1c(%rsp,%rbp,4),%xmm0
movss  0xa0(%rcx,%rdi,1),%xmm1
movss  0xbc(%rsp,%rbp,4),%xmm2
movss  (%rdx,%rdi,1),%xmm3
movaps %xmm0,%xmm4
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm3
mulss  %xmm1,%xmm4
subss  %xmm3,%xmm4
movss  %xmm4,(%rcx,%rdi,1)
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0xa4(%rdx,%rdi,1)
add    $0xffffffffffffff60,%rdi
add    $0xffffffffffffffff,%rbp
jg     15e0 <WebRtcIsac_NormLatticeFilterAr+0x4c0>
jmp    15b0 <WebRtcIsac_NormLatticeFilterAr+0x490>
nopl   0x0(%rax,%rax,1)
mov    0xb8(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
mov    $0xa0,%edx
lea    0x160(%rsp),%rsi
call   1030 <memcpy@plt>
test   %r12d,%r12d
mov    0x88(%rsp),%rdx
mov    0x8(%rsp),%rbp
js     1240 <WebRtcIsac_NormLatticeFilterAr+0x120>
cmp    $0x4,%r14d
setb   %al
or     0x7(%rsp),%al
je     1690 <WebRtcIsac_NormLatticeFilterAr+0x570>
xor    %ecx,%ecx
jmp    171e <WebRtcIsac_NormLatticeFilterAr+0x5fe>
nopl   0x0(%rax,%rax,1)
mov    $0x9f,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movss  -0x80(%rsp,%rax,4),%xmm0
movss  0x20(%rsp,%rax,4),%xmm1
unpcklps %xmm1,%xmm0
movss  0xc0(%rsp,%rax,4),%xmm1
movss  0x160(%rsp,%rax,4),%xmm2
unpcklps %xmm2,%xmm1
movlhps %xmm1,%xmm0
movups %xmm0,0x0(%r13,%rcx,1)
movss  0x7a0(%rsp,%rax,4),%xmm0
movss  0x840(%rsp,%rax,4),%xmm1
unpcklps %xmm1,%xmm0
movss  0x8e0(%rsp,%rax,4),%xmm1
movss  0x980(%rsp,%rax,4),%xmm2
unpcklps %xmm2,%xmm1
movlhps %xmm1,%xmm0
movups %xmm0,(%rbx,%rcx,1)
add    $0xa0,%rax
add    $0x10,%rcx
cmp    %rcx,%rdx
jne    16a0 <WebRtcIsac_NormLatticeFilterAr+0x580>
mov    0x50(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
je     1240 <WebRtcIsac_NormLatticeFilterAr+0x120>
mov    %rcx,%rax
test   $0x1,%r14b
je     1757 <WebRtcIsac_NormLatticeFilterAr+0x637>
mov    %rcx,%rax
shl    $0x5,%rax
lea    (%rax,%rax,4),%rax
movss  0x1fc(%rsp,%rax,1),%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
movss  0xa1c(%rsp,%rax,1),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x60(%rsp),%rcx
je     1240 <WebRtcIsac_NormLatticeFilterAr+0x120>
lea    (%rax,%rax,4),%rcx
lea    0x27(,%rcx,8),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x160(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
movss  0x980(%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x200(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%r13,%rax,4)
movss  0xa20(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
add    $0x2,%rax
add    $0x50,%rcx
cmp    %rax,%r14
jne    1780 <WebRtcIsac_NormLatticeFilterAr+0x660>
jmp    1240 <WebRtcIsac_NormLatticeFilterAr+0x120>
add    $0x11a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @WebRtcIsac_NormLatticeFilterAr(i32 %0, float* %1, float* %2, double* %3, double* %4, float* %5) {
%7 = alloca i32
%8 = alloca float*
%9 = alloca float*
%10 = alloca double*
%11 = alloca double*
%12 = alloca float*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca [12 x float]
%20 = alloca [12 x float]
%21 = alloca [13 x double]
%22 = alloca [13 x [40 x float]]
%23 = alloca [13 x [40 x float]]
%24 = alloca float
%25 = alloca float
store i32 %0, i32* %7
store float* %1, float** %8
store float* %2, float** %9
store double* %3, double** %10
store double* %4, double** %11
store float* %5, float** %12
%26 = load i32, i32* %7
%27 = add nsw i32 %26, 1
store i32 %27, i32* %18
store i32 0, i32* %16
br label %28
28: ; preds = %302, %6
%29 = load i32, i32* %16
%30 = icmp slt i32 %29, 6
br i1 %30, label %31, label %305
31: ; preds = %28
%32 = load i32, i32* %16
%33 = load i32, i32* %18
%34 = mul nsw i32 %32, %33
store i32 %34, i32* %17
%35 = getelementptr inbounds [13 x double], [13 x double]* %21, i64 0, i64 0
store double 1.000000e+00, double* %35
%36 = getelementptr inbounds [13 x double], [13 x double]* %21, i64 0, i64 0
%37 = getelementptr inbounds double, double* %36, i64 1
%38 = bitcast double* %37 to i8*
%39 = load double*, double** %11
%40 = load i32, i32* %17
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %39, i64 %41
%43 = getelementptr inbounds double, double* %42, i64 1
%44 = bitcast double* %43 to i8*
%45 = load i32, i32* %18
%46 = sub nsw i32 %45, 1
%47 = sext i32 %46 to i64
%48 = mul i64 8, %47
%49 = getelementptr inbounds [13 x double], [13 x double]* %21, i64 0, i64 0
%50 = load i32, i32* %7
%51 = getelementptr inbounds [12 x float], [12 x float]* %19, i64 0, i64 0
%52 = getelementptr inbounds [12 x float], [12 x float]* %20, i64 0, i64 0
%53 = call i32 (double*, i32, float*, float*, ...) bitcast (i32 (...)* @WebRtcIsac_Dir2Lat to i32 (double*, i32, float*, float*, ...)*)(double* %49, i32 %50, float* %51, float* %52)
%54 = load double*, double** %11
%55 = load i32, i32* %17
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %54, i64 %56
%58 = load double, double* %57
%59 = fptrunc double %58 to float
store float %59, float* %24
store i32 0, i32* %14
br label %60
60: ; preds = %71, %31
%61 = load i32, i32* %14
%62 = load i32, i32* %7
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %74
64: ; preds = %60
%65 = load i32, i32* %14
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [12 x float], [12 x float]* %20, i64 0, i64 %66
%68 = load float, float* %67
%69 = load float, float* %24
%70 = fmul float %68, %69
store float %70, float* %24
br label %71
71: ; preds = %64
%72 = load i32, i32* %14
%73 = add nsw i32 %72, 1
store i32 %73, i32* %14
br label %60
74: ; preds = %60
%75 = load float, float* %24
%76 = fdiv float 1.000000e+00, %75
store float %76, float* %25
store i32 0, i32* %15
br label %77
77: ; preds = %98, %74
%78 = load i32, i32* %15
%79 = icmp slt i32 %78, 40
br i1 %79, label %80, label %101
80: ; preds = %77
%81 = load double*, double** %10
%82 = load i32, i32* %15
%83 = load i32, i32* %16
%84 = mul nsw i32 %83, 40
%85 = add nsw i32 %82, %84
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds double, double* %81, i64 %86
%88 = load double, double* %87
%89 = fptrunc double %88 to float
%90 = load float, float* %25
%91 = fmul float %89, %90
%92 = load i32, i32* %7
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %93
%95 = load i32, i32* %15
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [40 x float], [40 x float]* %94, i64 0, i64 %96
store float %91, float* %97
br label %98
98: ; preds = %80
%99 = load i32, i32* %15
%100 = add nsw i32 %99, 1
store i32 %100, i32* %15
br label %77
101: ; preds = %77
%102 = load i32, i32* %7
%103 = sub nsw i32 %102, 1
store i32 %103, i32* %15
br label %104
104: ; preds = %160, %101
%105 = load i32, i32* %15
%106 = icmp sge i32 %105, 0
br i1 %106, label %107, label %163
107: ; preds = %104
%108 = load i32, i32* %15
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [12 x float], [12 x float]* %20, i64 0, i64 %109
%111 = load float, float* %110
%112 = load i32, i32* %15
%113 = add nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %114
%116 = getelementptr inbounds [40 x float], [40 x float]* %115, i64 0, i64 0
%117 = load float, float* %116
%118 = load i32, i32* %15
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [12 x float], [12 x float]* %19, i64 0, i64 %119
%121 = load float, float* %120
%122 = load float*, float** %9
%123 = load i32, i32* %15
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %122, i64 %124
%126 = load float, float* %125
%127 = fmul float %121, %126
%128 = fneg float %127
%129 = call float @llvm.fmuladd.f32(float %111, float %117, float %128)
%130 = load i32, i32* %15
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %131
%133 = getelementptr inbounds [40 x float], [40 x float]* %132, i64 0, i64 0
store float %129, float* %133
%134 = load i32, i32* %15
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [12 x float], [12 x float]* %19, i64 0, i64 %135
%137 = load float, float* %136
%138 = load i32, i32* %15
%139 = add nsw i32 %138, 1
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %140
%142 = getelementptr inbounds [40 x float], [40 x float]* %141, i64 0, i64 0
%143 = load float, float* %142
%144 = load i32, i32* %15
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [12 x float], [12 x float]* %20, i64 0, i64 %145
%147 = load float, float* %146
%148 = load float*, float** %9
%149 = load i32, i32* %15
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %148, i64 %150
%152 = load float, float* %151
%153 = fmul float %147, %152
%154 = call float @llvm.fmuladd.f32(float %137, float %143, float %153)
%155 = load i32, i32* %15
%156 = add nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %23, i64 0, i64 %157
%159 = getelementptr inbounds [40 x float], [40 x float]* %158, i64 0, i64 0
store float %154, float* %159
br label %160
160: ; preds = %107
%161 = load i32, i32* %15
%162 = add nsw i32 %161, -1
store i32 %162, i32* %15
br label %104
163: ; preds = %104
%164 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 0
%165 = getelementptr inbounds [40 x float], [40 x float]* %164, i64 0, i64 0
%166 = load float, float* %165
%167 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %23, i64 0, i64 0
%168 = getelementptr inbounds [40 x float], [40 x float]* %167, i64 0, i64 0
store float %166, float* %168
store i32 0, i32* %13
br label %169
169: ; preds = %262, %163
%170 = load i32, i32* %13
%171 = icmp slt i32 %170, 39
br i1 %171, label %172, label %265
172: ; preds = %169
%173 = load i32, i32* %7
%174 = sub nsw i32 %173, 1
store i32 %174, i32* %14
br label %175
175: ; preds = %247, %172
%176 = load i32, i32* %14
%177 = icmp sge i32 %176, 0
br i1 %177, label %178, label %250
178: ; preds = %175
%179 = load i32, i32* %14
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [12 x float], [12 x float]* %20, i64 0, i64 %180
%182 = load float, float* %181
%183 = load i32, i32* %14
%184 = add nsw i32 %183, 1
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %185
%187 = load i32, i32* %13
%188 = add nsw i32 %187, 1
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [40 x float], [40 x float]* %186, i64 0, i64 %189
%191 = load float, float* %190
%192 = load i32, i32* %14
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [12 x float], [12 x float]* %19, i64 0, i64 %193
%195 = load float, float* %194
%196 = load i32, i32* %14
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %23, i64 0, i64 %197
%199 = load i32, i32* %13
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [40 x float], [40 x float]* %198, i64 0, i64 %200
%202 = load float, float* %201
%203 = fmul float %195, %202
%204 = fneg float %203
%205 = call float @llvm.fmuladd.f32(float %182, float %191, float %204)
%206 = load i32, i32* %14
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %207
%209 = load i32, i32* %13
%210 = add nsw i32 %209, 1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [40 x float], [40 x float]* %208, i64 0, i64 %211
store float %205, float* %212
%213 = load i32, i32* %14
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [12 x float], [12 x float]* %19, i64 0, i64 %214
%216 = load float, float* %215
%217 = load i32, i32* %14
%218 = add nsw i32 %217, 1
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %219
%221 = load i32, i32* %13
%222 = add nsw i32 %221, 1
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [40 x float], [40 x float]* %220, i64 0, i64 %223
%225 = load float, float* %224
%226 = load i32, i32* %14
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [12 x float], [12 x float]* %20, i64 0, i64 %227
%229 = load float, float* %228
%230 = load i32, i32* %14
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %23, i64 0, i64 %231
%233 = load i32, i32* %13
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [40 x float], [40 x float]* %232, i64 0, i64 %234
%236 = load float, float* %235
%237 = fmul float %229, %236
%238 = call float @llvm.fmuladd.f32(float %216, float %225, float %237)
%239 = load i32, i32* %14
%240 = add nsw i32 %239, 1
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %23, i64 0, i64 %241
%243 = load i32, i32* %13
%244 = add nsw i32 %243, 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds [40 x float], [40 x float]* %242, i64 0, i64 %245
store float %238, float* %246
br label %247
247: ; preds = %178
%248 = load i32, i32* %14
%249 = add nsw i32 %248, -1
store i32 %249, i32* %14
br label %175
250: ; preds = %175
%251 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 0
%252 = load i32, i32* %13
%253 = add nsw i32 %252, 1
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [40 x float], [40 x float]* %251, i64 0, i64 %254
%256 = load float, float* %255
%257 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %23, i64 0, i64 0
%258 = load i32, i32* %13
%259 = add nsw i32 %258, 1
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [40 x float], [40 x float]* %257, i64 0, i64 %260
store float %256, float* %261
br label %262
262: ; preds = %250
%263 = load i32, i32* %13
%264 = add nsw i32 %263, 1
store i32 %264, i32* %13
br label %169
265: ; preds = %169
%266 = load float*, float** %12
%267 = load i32, i32* %16
%268 = mul nsw i32 %267, 40
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds float, float* %266, i64 %269
%271 = bitcast float* %270 to i8*
%272 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 0
%273 = getelementptr inbounds [40 x float], [40 x float]* %272, i64 0, i64 0
%274 = bitcast float* %273 to i8*
store i32 0, i32* %15
br label %275
275: ; preds = %298, %265
%276 = load i32, i32* %15
%277 = load i32, i32* %18
%278 = icmp slt i32 %276, %277
br i1 %278, label %279, label %301
279: ; preds = %275
%280 = load i32, i32* %15
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %22, i64 0, i64 %281
%283 = getelementptr inbounds [40 x float], [40 x float]* %282, i64 0, i64 39
%284 = load float, float* %283
%285 = load float*, float** %8
%286 = load i32, i32* %15
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %285, i64 %287
store float %284, float* %288
%289 = load i32, i32* %15
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds [13 x [40 x float]], [13 x [40 x float]]* %23, i64 0, i64 %290
%292 = getelementptr inbounds [40 x float], [40 x float]* %291, i64 0, i64 39
%293 = load float, float* %292
%294 = load float*, float** %9
%295 = load i32, i32* %15
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %294, i64 %296
store float %293, float* %297
br label %298
298: ; preds = %279
%299 = load i32, i32* %15
%300 = add nsw i32 %299, 1
store i32 %300, i32* %15
br label %275
301: ; preds = %275
br label %302
302: ; preds = %301
%303 = load i32, i32* %16
%304 = add nsw i32 %303, 1
store i32 %304, i32* %16
br label %28
305: ; preds = %28
ret void
}

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