#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*/ memset(float *, int /*<<< orphan*/, int);
int FrameClassify(float *residual) {
  float max_ssqEn, fssqEn[6], bssqEn[6], *pp;
  int n, l, max_ssqEn_n;
  const float ssqEn_win[6 - 1] = {(float)0.8, (float)0.9, (float)1.0,
                                  (float)0.9, (float)0.8};
  const float sampEn_win[5] = {(float)1.0 / (float)6.0, (float)2.0 / (float)6.0,
                               (float)3.0 / (float)6.0, (float)4.0 / (float)6.0,
                               (float)5.0 / (float)6.0};
  memset(fssqEn, 0, 6 * sizeof(float));
  memset(bssqEn, 0, 6 * sizeof(float));
  n = 0;
  pp = residual;
  for (l = 0; l < 5; l++) {
    fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
    pp++;
  }
  for (l = 5; l < 40; l++) {
    fssqEn[n] += (*pp) * (*pp);
    pp++;
  }
  for (n = 1; n < 6 - 1; n++) {
    pp = residual + n * 40;
    for (l = 0; l < 5; l++) {
      fssqEn[n] += sampEn_win[l] * (*pp) * (*pp);
      bssqEn[n] += (*pp) * (*pp);
      pp++;
    }
    for (l = 5; l < 40 - 5; l++) {
      fssqEn[n] += (*pp) * (*pp);
      bssqEn[n] += (*pp) * (*pp);
      pp++;
    }
    for (l = 40 - 5; l < 40; l++) {
      fssqEn[n] += (*pp) * (*pp);
      bssqEn[n] += sampEn_win[40 - l - 1] * (*pp) * (*pp);
      pp++;
    }
  }
  n = 6 - 1;
  pp = residual + n * 40;
  for (l = 0; l < 40 - 5; l++) {
    bssqEn[n] += (*pp) * (*pp);
    pp++;
  }
  for (l = 40 - 5; l < 40; l++) {
    bssqEn[n] += sampEn_win[40 - l - 1] * (*pp) * (*pp);
    pp++;
  }
  max_ssqEn = (fssqEn[0] + bssqEn[1]) * ssqEn_win[0];
  max_ssqEn_n = 1;
  for (n = 2; n < 6; n++) {
    if ((fssqEn[n - 1] + bssqEn[n]) * ssqEn_win[n - 1] > max_ssqEn) {
      max_ssqEn = (fssqEn[n - 1] + bssqEn[n]) * ssqEn_win[n - 1];
      max_ssqEn_n = n;
    }
  }
  return max_ssqEn_n;
}


x86 assembly (clang, -O0):
<FrameClassify>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    0xeda(%rip),%rax
mov    %rax,-0x80(%rbp)
mov    0xed7(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    0xed5(%rip),%eax
mov    %eax,-0x70(%rbp)
mov    0xedb(%rip),%rax
mov    %rax,-0xa0(%rbp)
mov    0xed5(%rip),%rax
mov    %rax,-0x98(%rbp)
mov    0xed0(%rip),%eax
mov    %eax,-0x90(%rbp)
lea    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x5,-0x60(%rbp)
jge    11f5 <FrameClassify+0xe5>
movslq -0x60(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    119c <FrameClassify+0x8c>
movl   $0x5,-0x60(%rbp)
cmpl   $0x28,-0x60(%rbp)
jge    1248 <FrameClassify+0x138>
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11fc <FrameClassify+0xec>
movl   $0x1,-0x5c(%rbp)
cmpl   $0x5,-0x5c(%rbp)
jge    1416 <FrameClassify+0x306>
mov    -0x8(%rbp),%rax
imul   $0x28,-0x5c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x5,-0x60(%rbp)
jge    12f7 <FrameClassify+0x1e7>
movslq -0x60(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1276 <FrameClassify+0x166>
movl   $0x5,-0x60(%rbp)
cmpl   $0x23,-0x60(%rbp)
jge    1372 <FrameClassify+0x262>
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12fe <FrameClassify+0x1ee>
movl   $0x23,-0x60(%rbp)
cmpl   $0x28,-0x60(%rbp)
jge    1403 <FrameClassify+0x2f3>
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    $0x28,%eax
sub    -0x60(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1379 <FrameClassify+0x269>
jmp    1408 <FrameClassify+0x2f8>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    124f <FrameClassify+0x13f>
movl   $0x5,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x28,-0x5c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x23,-0x60(%rbp)
jge    1486 <FrameClassify+0x376>
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    143a <FrameClassify+0x32a>
movl   $0x23,-0x60(%rbp)
cmpl   $0x28,-0x60(%rbp)
jge    14ef <FrameClassify+0x3df>
mov    $0x28,%eax
sub    -0x60(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm2
movslq -0x5c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    148d <FrameClassify+0x37d>
movss  -0x30(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
movl   $0x1,-0x64(%rbp)
movl   $0x2,-0x5c(%rbp)
cmpl   $0x6,-0x5c(%rbp)
jge    158f <FrameClassify+0x47f>
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x30(%rbp,%rax,4),%xmm0
movslq -0x5c(%rbp),%rax
addss  -0x50(%rbp,%rax,4),%xmm0
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
cltq
mulss  -0x80(%rbp,%rax,4),%xmm0
ucomiss -0xc(%rbp),%xmm0
jbe    157c <FrameClassify+0x46c>
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x30(%rbp,%rax,4),%xmm0
movslq -0x5c(%rbp),%rax
addss  -0x50(%rbp,%rax,4),%xmm0
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
cltq
mulss  -0x80(%rbp,%rax,4),%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1581 <FrameClassify+0x471>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1511 <FrameClassify+0x401>
mov    -0x64(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FrameClassify>:
push   %rbx
sub    $0x40,%rsp
mov    %rdi,%rbx
mov    %rsp,%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0x20(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movss  (%rbx),%xmm2
movss  0x4(%rbx),%xmm3
movss  0x8(%rbx),%xmm4
movss  0xc(%rbx),%xmm9
movss  0x10(%rbx),%xmm8
movss  0xea6(%rip),%xmm0
mulss  %xmm8,%xmm0
movss  0xe9d(%rip),%xmm6
mulss  %xmm9,%xmm6
movss  0xe94(%rip),%xmm7
mulss  %xmm4,%xmm7
movss  0xe8c(%rip),%xmm1
mulss  %xmm3,%xmm1
movss  0xe84(%rip),%xmm5
mulss  %xmm2,%xmm5
mulss  %xmm2,%xmm5
addss  (%rsp),%xmm5
mulss  %xmm3,%xmm1
addss  %xmm5,%xmm1
mulss  %xmm4,%xmm7
addss  %xmm1,%xmm7
mulss  %xmm9,%xmm6
addss  %xmm7,%xmm6
mulss  %xmm8,%xmm0
addss  %xmm6,%xmm0
movss  0x14(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x18(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x1c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x24(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x28(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x2c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x34(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x38(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x3c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x40(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x44(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x48(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x4c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x50(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x54(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x58(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x5c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x60(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x64(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x68(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x6c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x70(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x74(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x78(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x7c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x80(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x84(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x88(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x8c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x90(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x94(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x98(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x9c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsp)
lea    0xb4(%rbx),%rax
mov    $0x1,%ecx
movss  0xc5c(%rip),%xmm8
movss  0xc50(%rip),%xmm1
movss  0xc44(%rip),%xmm2
movss  0xc38(%rip),%xmm3
movss  0xc2c(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rcx,%rcx,4),%rdx
shl    $0x5,%rdx
movss  (%rbx,%rdx,1),%xmm6
movss  0x4(%rbx,%rdx,1),%xmm5
movaps %xmm6,%xmm7
mulss  %xmm8,%xmm7
unpcklps %xmm6,%xmm7
shufps $0x0,%xmm6,%xmm6
mulps  %xmm7,%xmm6
movss  0x20(%rsp,%rcx,4),%xmm7
movss  (%rsp,%rcx,4),%xmm0
unpcklps %xmm7,%xmm0
addps  %xmm6,%xmm0
movaps %xmm5,%xmm6
mulss  %xmm1,%xmm6
unpcklps %xmm5,%xmm6
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm0,%xmm5
movss  0x8(%rbx,%rdx,1),%xmm0
movaps %xmm0,%xmm6
mulss  %xmm2,%xmm6
unpcklps %xmm0,%xmm6
shufps $0x0,%xmm0,%xmm0
mulps  %xmm6,%xmm0
addps  %xmm5,%xmm0
movss  0xc(%rbx,%rdx,1),%xmm6
movaps %xmm6,%xmm5
mulss  %xmm3,%xmm5
unpcklps %xmm6,%xmm5
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm0,%xmm6
movss  0x10(%rbx,%rdx,1),%xmm5
movaps %xmm5,%xmm0
mulss  %xmm4,%xmm0
unpcklps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm5
mulps  %xmm0,%xmm5
addps  %xmm6,%xmm5
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
movss  0x4(%rax,%rdx,4),%xmm6
mulss  %xmm0,%xmm0
shufps $0x0,%xmm0,%xmm0
addps  %xmm5,%xmm0
mulss  %xmm6,%xmm6
shufps $0x0,%xmm6,%xmm6
addps  %xmm0,%xmm6
movss  0x8(%rax,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
shufps $0x0,%xmm0,%xmm0
addps  %xmm6,%xmm0
movss  0xc(%rax,%rdx,4),%xmm6
mulss  %xmm6,%xmm6
shufps $0x0,%xmm6,%xmm6
addps  %xmm0,%xmm6
movss  0x10(%rax,%rdx,4),%xmm5
mulss  %xmm5,%xmm5
shufps $0x0,%xmm5,%xmm5
addps  %xmm6,%xmm5
add    $0x5,%rdx
cmp    $0x1e,%edx
jne    1480 <FrameClassify+0x370>
movss  (%rax,%rdx,4),%xmm0
movss  0x4(%rax,%rdx,4),%xmm6
movaps %xmm0,%xmm7
mulss  %xmm4,%xmm7
mulss  %xmm0,%xmm7
mulss  %xmm0,%xmm0
addss  %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm5
addss  %xmm5,%xmm7
movaps %xmm6,%xmm5
mulss  %xmm3,%xmm5
mulss  %xmm6,%xmm5
mulss  %xmm6,%xmm6
addss  %xmm0,%xmm6
addss  %xmm7,%xmm5
movss  0x8(%rax,%rdx,4),%xmm0
movaps %xmm0,%xmm7
mulss  %xmm2,%xmm7
mulss  %xmm0,%xmm7
mulss  %xmm0,%xmm0
addss  %xmm6,%xmm0
addss  %xmm5,%xmm7
movss  0xc(%rax,%rdx,4),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm5,%xmm6
mulss  %xmm5,%xmm5
addss  %xmm0,%xmm5
addss  %xmm7,%xmm6
movss  0x10(%rax,%rdx,4),%xmm0
movaps %xmm0,%xmm7
mulss  %xmm8,%xmm7
mulss  %xmm0,%xmm7
mulss  %xmm0,%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,(%rsp,%rcx,4)
addss  %xmm6,%xmm7
movss  %xmm7,0x20(%rsp,%rcx,4)
add    $0x1,%rcx
add    $0xa0,%rax
cmp    $0x5,%rcx
jne    13e0 <FrameClassify+0x2d0>
movss  0x320(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  0x34(%rsp),%xmm0
movss  0x324(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x328(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x32c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x330(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x334(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x338(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x33c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x340(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x344(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x348(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x34c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x350(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x354(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x358(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x35c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x360(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x364(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x368(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x36c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x370(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x374(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x378(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x37c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x380(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x384(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x388(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x38c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x390(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x394(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x398(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x39c(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x3a0(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x3a4(%rbx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x3a8(%rbx),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x3ac(%rbx),%xmm1
movss  0x82d(%rip),%xmm2
mulss  %xmm1,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  0x3b0(%rbx),%xmm0
movss  0x815(%rip),%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  0x3b4(%rbx),%xmm0
movss  0x7fd(%rip),%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  0x3b8(%rbx),%xmm1
movss  0x7e5(%rip),%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
addss  %xmm2,%xmm0
movss  0x3bc(%rbx),%xmm2
movss  0x7cd(%rip),%xmm1
mulss  %xmm2,%xmm1
movsd  (%rsp),%xmm3
movsd  0x24(%rsp),%xmm4
addps  %xmm3,%xmm4
mulps  0x7c4(%rip),%xmm4
movaps %xmm4,%xmm3
shufps $0x55,%xmm4,%xmm3
xor    %eax,%eax
ucomiss %xmm4,%xmm3
seta   %al
mulss  %xmm2,%xmm1
maxss  %xmm4,%xmm3
add    $0x1,%eax
movss  0x8(%rsp),%xmm2
addss  0x2c(%rsp),%xmm2
ucomiss %xmm3,%xmm2
mov    $0x3,%ecx
cmovbe %eax,%ecx
maxss  %xmm3,%xmm2
movss  0xc(%rsp),%xmm3
addss  0x30(%rsp),%xmm3
mulss  0x76f(%rip),%xmm3
ucomiss %xmm2,%xmm3
mov    $0x4,%edx
cmovbe %ecx,%edx
addss  %xmm0,%xmm1
maxss  %xmm2,%xmm3
addss  0x10(%rsp),%xmm1
mulss  0x752(%rip),%xmm1
ucomiss %xmm3,%xmm1
mov    $0x5,%eax
cmovbe %edx,%eax
add    $0x40,%rsp
pop    %rbx
ret

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

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