#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ WebRtcIsac_Dir2Lat(double *, int, float *, float *);
int /*<<< orphan*/ memcpy(double *, double *, int);
void WebRtcIsac_NormLatticeFilterMa(int orderCoef, float *stateF, float *stateG,
                                    float *lat_in, double *filtcoeflo,
                                    double *lat_out) {
  int n, k, i, u, temp1;
  int ord_1 = orderCoef + 1;
  float sth[12];
  float cth[12];
  float inv_cth[12];
  double a[12 + 1];
  float f[12 + 1][(80 / 2)], g[12 + 1][(80 / 2)];
  float gain1;
  for (u = 0; u < 6; u++) {
    temp1 = u * ord_1;
    a[0] = 1;
    memcpy(a + 1, filtcoeflo + temp1 + 1, sizeof(double) * (ord_1 - 1));
    WebRtcIsac_Dir2Lat(a, orderCoef, sth, cth);
    gain1 = (float)filtcoeflo[temp1];
    for (k = 0; k < orderCoef; k++) {
      gain1 *= cth[k];
      inv_cth[k] = 1 / cth[k];
    }
    for (i = 0; i < (80 / 2); i++) {
      f[0][i] = lat_in[i + u * (80 / 2)];
      g[0][i] = lat_in[i + u * (80 / 2)];
    }
    for (i = 1; i < ord_1; i++) {
      f[i][0] = inv_cth[i - 1] * (f[i - 1][0] + sth[i - 1] * stateG[i - 1]);
      g[i][0] = cth[i - 1] * stateG[i - 1] + sth[i - 1] * f[i][0];
    }
    for (k = 0; k < orderCoef; k++) {
      for (n = 0; n < ((80 / 2) - 1); n++) {
        f[k + 1][n + 1] = inv_cth[k] * (f[k][n + 1] + sth[k] * g[k][n]);
        g[k + 1][n + 1] = cth[k] * g[k][n] + sth[k] * f[k + 1][n + 1];
      }
    }
    for (n = 0; n < (80 / 2); n++) {
      lat_out[n + u * (80 / 2)] = gain1 * f[orderCoef][n];
    }
    for (i = 0; i < ord_1; i++) {
      stateF[i] = f[i][(80 / 2) - 1];
      stateG[i] = g[i][(80 / 2) - 1];
    }
  }
  return;
}


x86 assembly (clang, -O0):
<WebRtcIsac_NormLatticeFilterMa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x11a0,%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    15e1 <WebRtcIsac_NormLatticeFilterMa+0x4c1>
mov    -0x40(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  0xe92(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
lea    -0x150(%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
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
lea    -0x150(%rbp),%rdi
mov    -0x4(%rbp),%esi
lea    -0x80(%rbp),%rdx
lea    -0xb0(%rbp),%rcx
call   1040 <WebRtcIsac_Dir2Lat@plt>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1194(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    123a <WebRtcIsac_NormLatticeFilterMa+0x11a>
movslq -0x38(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mulss  -0x1194(%rbp),%xmm0
ff
movss  %xmm0,-0x1194(%rbp)
ff
movslq -0x38(%rbp),%rax
movss  0xdf2(%rip),%xmm0
divss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movss  %xmm0,-0xe0(%rbp,%rax,4)
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11e1 <WebRtcIsac_NormLatticeFilterMa+0xc1>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x28,-0x3c(%rbp)
jge    129d <WebRtcIsac_NormLatticeFilterMa+0x17d>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x28,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x3c(%rbp),%rax
movss  %xmm0,-0x970(%rbp,%rax,4)
ff ff
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x28,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x3c(%rbp),%rax
movss  %xmm0,-0x1190(%rbp,%rax,4)
ff ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1241 <WebRtcIsac_NormLatticeFilterMa+0x121>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    139d <WebRtcIsac_NormLatticeFilterMa+0x27d>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x970(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  (%rax),%xmm2
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x80(%rbp,%rax,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movslq -0x3c(%rbp),%rcx
lea    -0x970(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x80(%rbp,%rax,4),%xmm1
movslq -0x3c(%rbp),%rcx
lea    -0x970(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
mulss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x3c(%rbp),%rcx
lea    -0x1190(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12a4 <WebRtcIsac_NormLatticeFilterMa+0x184>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14fb <WebRtcIsac_NormLatticeFilterMa+0x3db>
movl   $0x0,-0x34(%rbp)
cmpl   $0x27,-0x34(%rbp)
jge    14e8 <WebRtcIsac_NormLatticeFilterMa+0x3c8>
movslq -0x38(%rbp),%rax
movss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x38(%rbp),%rcx
lea    -0x970(%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    -0x1190(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x38(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x970(%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  -0xb0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x38(%rbp),%rcx
lea    -0x1190(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x38(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm1
mov    -0x38(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x970(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1190(%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13b7 <WebRtcIsac_NormLatticeFilterMa+0x297>
jmp    14ed <WebRtcIsac_NormLatticeFilterMa+0x3cd>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13a4 <WebRtcIsac_NormLatticeFilterMa+0x284>
movl   $0x0,-0x34(%rbp)
cmpl   $0x28,-0x34(%rbp)
jge    1559 <WebRtcIsac_NormLatticeFilterMa+0x439>
movss  -0x1194(%rbp),%xmm0
ff
movslq -0x4(%rbp),%rcx
lea    -0x970(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x28,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1502 <WebRtcIsac_NormLatticeFilterMa+0x3e2>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15ce <WebRtcIsac_NormLatticeFilterMa+0x4ae>
movslq -0x3c(%rbp),%rcx
lea    -0x970(%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    -0x1190(%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    1560 <WebRtcIsac_NormLatticeFilterMa+0x440>
jmp    15d3 <WebRtcIsac_NormLatticeFilterMa+0x4b3>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1152 <WebRtcIsac_NormLatticeFilterMa+0x32>
add    $0x11a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<WebRtcIsac_NormLatticeFilterMa>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x11d8,%rsp
mov    %r9,0x80(%rsp)
mov    %r8,0x78(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rdx,%rbx
mov    %rsi,%r13
lea    0x1(%rdi),%esi
mov    %rdi,0x8(%rsp)
movslq %edi,%rax
mov    %eax,%edi
lea    0x0(,%rax,8),%ecx
mov    %ecx,0x1c(%rsp)
lea    0x0(,%rsi,4),%r8
add    %r13,%r8
lea    (%rdx,%rsi,4),%rdx
mov    %edi,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x40(%rsp)
lea    (%rax,%rax,4),%rax
shl    $0x5,%rax
add    %rsp,%rax
add    $0x190,%rax
mov    %rax,0x60(%rsp)
cmp    %r13,%rdx
seta   %al
cmp    %rbx,%r8
seta   %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
mov    %esi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rsi,4),%rdx
and    $0xfffffffffffffff0,%rdx
movslq %esi,%rax
mov    %rax,0x50(%rsp)
lea    -0x4(,%rsi,4),%r12
ff
xor    %ebp,%ebp
mov    %rsi,0x68(%rsp)
mov    %rdi,0x10(%rsp)
mov    %rdx,0x58(%rsp)
jmp    11fe <WebRtcIsac_NormLatticeFilterMa+0xde>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x6,%rbp
je     17af <WebRtcIsac_NormLatticeFilterMa+0x68f>
lea    0x0(,%rbp,8),%rax
mov    %rax,0x20(%rsp)
mov    0x8(%rsp),%r14
mov    %rbp,0x88(%rsp)
imul   0x50(%rsp),%rbp
movabs $0x3ff0000000000000,%rax
mov    %rax,0x120(%rsp)
mov    0x78(%rsp),%r15
lea    (%r15,%rbp,8),%rsi
add    $0x8,%rsi
lea    0x128(%rsp),%rdi
mov    0x1c(%rsp),%edx
call   1030 <memcpy@plt>
lea    0x120(%rsp),%rdi
mov    %r14d,%esi
lea    0xf0(%rsp),%rdx
lea    0x90(%rsp),%rcx
call   1040 <WebRtcIsac_Dir2Lat@plt>
movsd  (%r15,%rbp,8),%xmm0
cvtsd2ss %xmm0,%xmm4
test   %r14d,%r14d
jle    12a0 <WebRtcIsac_NormLatticeFilterMa+0x180>
cmpl   $0x1,0x8(%rsp)
jne    12b0 <WebRtcIsac_NormLatticeFilterMa+0x190>
xor    %eax,%eax
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%rsi
jmp    1313 <WebRtcIsac_NormLatticeFilterMa+0x1f3>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%rsi
jmp    133a <WebRtcIsac_NormLatticeFilterMa+0x21a>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x10(%rsp),%rcx
mov    0x40(%rsp),%rdx
movss  0xd3c(%rip),%xmm3
mov    0x20(%rsp),%rsi
nopl   0x0(%rax)
movss  0x90(%rsp,%rax,4),%xmm0
movss  0x94(%rsp,%rax,4),%xmm1
mulss  %xmm0,%xmm4
movaps %xmm3,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,0xc0(%rsp,%rax,4)
mulss  %xmm1,%xmm4
movaps %xmm3,%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc4(%rsp,%rax,4)
add    $0x2,%rax
cmp    %rax,%rdx
jne    12d0 <WebRtcIsac_NormLatticeFilterMa+0x1b0>
test   $0x1,%cl
je     133a <WebRtcIsac_NormLatticeFilterMa+0x21a>
movss  0x90(%rsp,%rax,4),%xmm0
mulss  %xmm0,%xmm4
movss  0xcd3(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc0(%rsp,%rax,4)
movaps %xmm4,0x20(%rsp)
lea    (%rsi,%rsi,4),%r14
mov    0x70(%rsp),%rax
lea    (%rax,%r14,4),%r15
mov    $0xa0,%edx
lea    0x190(%rsp),%rdi
mov    %r15,%rsi
call   1030 <memcpy@plt>
mov    $0xa0,%edx
lea    0x9b0(%rsp),%rdi
mov    %r15,%rsi
call   1030 <memcpy@plt>
cmpl   $0x0,0x8(%rsp)
jle    13e5 <WebRtcIsac_NormLatticeFilterMa+0x2c5>
mov    $0x28,%eax
movss  0x190(%rsp),%xmm0
xor    %ecx,%ecx
nopl   (%rax)
movss  0xf0(%rsp,%rcx,1),%xmm1
movss  (%rbx,%rcx,1),%xmm2
movaps %xmm1,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
mulss  0xc0(%rsp,%rcx,1),%xmm3
movss  %xmm3,0x190(%rsp,%rax,4)
mulss  %xmm3,%xmm1
mulss  0x90(%rsp,%rcx,1),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x9b0(%rsp,%rax,4)
add    $0x4,%rcx
add    $0x28,%rax
movaps %xmm3,%xmm0
cmp    %rcx,%r12
jne    1390 <WebRtcIsac_NormLatticeFilterMa+0x270>
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%rdi
jle    148c <WebRtcIsac_NormLatticeFilterMa+0x36c>
lea    0x234(%rsp),%rax
lea    0xa54(%rsp),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  0xc0(%rsp,%rdx,4),%xmm0
movss  0xf0(%rsp,%rdx,4),%xmm1
movss  0x90(%rsp,%rdx,4),%xmm2
add    $0x1,%rdx
mov    $0xffffffffffffffd9,%rsi
cs nopw 0x0(%rax,%rax,1)
movss  -0x8(%rcx,%rsi,4),%xmm3
movaps %xmm1,%xmm4
mulss  %xmm3,%xmm4
addss  -0x4(%rax,%rsi,4),%xmm4
mulss  %xmm0,%xmm4
movss  %xmm4,0x9c(%rax,%rsi,4)
mulss  %xmm1,%xmm4
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,0x9c(%rcx,%rsi,4)
inc    %rsi
jne    1440 <WebRtcIsac_NormLatticeFilterMa+0x320>
add    $0xa0,%rcx
add    $0xa0,%rax
cmp    %rdi,%rdx
jne    1410 <WebRtcIsac_NormLatticeFilterMa+0x2f0>
lea    0x0(,%r14,8),%rax
mov    %rax,%rcx
or     $0x10,%rcx
mov    %rax,%rdx
movaps 0x20(%rsp),%xmm1
shufps $0x0,%xmm1,%xmm1
mov    0x60(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
or     $0x20,%rdx
mov    0x80(%rsp),%rsi
movups %xmm0,(%rsi,%r14,8)
movsd  0x8(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,(%rsi,%rcx,1)
movsd  0x10(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,(%rsi,%rdx,1)
movsd  0x18(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
or     $0x30,%rax
movups %xmm0,(%rsi,%rax,1)
movsd  0x20(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x40(%rsi,%r14,8)
movsd  0x28(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x50(%rsi,%r14,8)
movsd  0x30(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x60(%rsi,%r14,8)
movsd  0x38(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x70(%rsi,%r14,8)
movsd  0x40(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x80(%rsi,%r14,8)
movsd  0x48(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x90(%rsi,%r14,8)
movsd  0x50(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0xa0(%rsi,%r14,8)
movsd  0x58(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0xb0(%rsi,%r14,8)
movsd  0x60(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0xc0(%rsi,%r14,8)
movsd  0x68(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0xd0(%rsi,%r14,8)
movsd  0x70(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0xe0(%rsi,%r14,8)
movsd  0x78(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0xf0(%rsi,%r14,8)
movsd  0x80(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x100(%rsi,%r14,8)
movsd  0x88(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x110(%rsi,%r14,8)
movsd  0x90(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x120(%rsi,%r14,8)
movsd  0x98(%rbp),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,0x130(%rsi,%r14,8)
cmpl   $0x0,0x8(%rsp)
mov    0x68(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    0x88(%rsp),%rbp
js     11f0 <WebRtcIsac_NormLatticeFilterMa+0xd0>
cmp    $0x4,%esi
setb   %al
or     0x7(%rsp),%al
je     1670 <WebRtcIsac_NormLatticeFilterMa+0x550>
xor    %ecx,%ecx
jmp    16fe <WebRtcIsac_NormLatticeFilterMa+0x5de>
nopl   0x0(%rax)
mov    $0x9f,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movss  -0x50(%rsp,%rax,4),%xmm0
movss  0x50(%rsp,%rax,4),%xmm1
unpcklps %xmm1,%xmm0
movss  0xf0(%rsp,%rax,4),%xmm1
movss  0x190(%rsp,%rax,4),%xmm2
unpcklps %xmm2,%xmm1
movlhps %xmm1,%xmm0
movups %xmm0,0x0(%r13,%rcx,1)
movss  0x7d0(%rsp,%rax,4),%xmm0
movss  0x870(%rsp,%rax,4),%xmm1
unpcklps %xmm1,%xmm0
movss  0x910(%rsp,%rax,4),%xmm1
movss  0x9b0(%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    1680 <WebRtcIsac_NormLatticeFilterMa+0x560>
mov    0x38(%rsp),%rax
mov    %rax,%rcx
cmp    %rsi,%rax
je     11f0 <WebRtcIsac_NormLatticeFilterMa+0xd0>
mov    %rcx,%rax
test   $0x1,%sil
je     1737 <WebRtcIsac_NormLatticeFilterMa+0x617>
mov    %rcx,%rax
shl    $0x5,%rax
lea    (%rax,%rax,4),%rax
movss  0x22c(%rsp,%rax,1),%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
movss  0xa4c(%rsp,%rax,1),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x48(%rsp),%rcx
je     11f0 <WebRtcIsac_NormLatticeFilterMa+0xd0>
lea    (%rax,%rax,4),%rcx
lea    0x27(,%rcx,8),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x190(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
movss  0x9b0(%rsp,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x230(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%r13,%rax,4)
movss  0xa50(%rsp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
add    $0x2,%rax
add    $0x50,%rcx
cmp    %rax,%rsi
jne    1760 <WebRtcIsac_NormLatticeFilterMa+0x640>
jmp    11f0 <WebRtcIsac_NormLatticeFilterMa+0xd0>
add    $0x11d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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