#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 */
scalar_t__ calloc(int, int);
int fmaxi(float *, int);
float fmean(float *, int);
int fmini(float *, int);
int /*<<< orphan*/ free(float *);
void kalman(float *obs, int duration) {
  int i;
  float predictor, J, initial, means;
  float *obsVar, initMean, initVar, seqVar, *stateMean, *stateVar;
  means = fmean(obs, duration);
  obsVar = (float *)calloc(duration, sizeof(float));
  for (i = 0; i < duration; i++)
    if (obs[i] > 0)
      obsVar[i] = 40;
    else {
      obs[i] = means;
      obsVar[i] = 250000;
    }
  seqVar = 1e+2;
  initMean =
      fmini(obs, duration) + (fmaxi(obs, duration) - fmini(obs, duration)) / 2;
  initVar = (fmaxi(obs, duration) - fmini(obs, duration)) *
            (fmaxi(obs, duration) - fmini(obs, duration));
  stateMean = (float *)calloc(duration, sizeof(float));
  stateVar = (float *)calloc(duration, sizeof(float));
  stateMean[0] =
      (obs[0] * initVar + initMean * obsVar[0]) / (initVar + obsVar[0]);
  stateVar[0] = initVar * obsVar[0] / (initVar + obsVar[0]);
  for (i = 1; i < duration; i++) {
    predictor = seqVar + stateVar[i - 1];
    stateMean[i] = (obs[i] * predictor + stateMean[i - 1] * obsVar[i]) /
                   (predictor + obsVar[i]);
    stateVar[i] = predictor * obsVar[i] / (predictor + obsVar[i]);
  }
  for (i = duration - 2; i >= 0; i--) {
    stateMean[i] = stateMean[i + 1] * stateVar[i] + stateMean[i] * seqVar;
    stateMean[i] /= seqVar + stateVar[i];
    J = stateVar[i] / (stateVar[i] + seqVar);
    stateVar[i] = J * (seqVar + J * stateVar[i + 1]);
  }
  for (i = 0; i < duration; i++) {
    obs[i] = stateMean[i];
  }
  free(stateVar);
  free(stateMean);
  free(obsVar);
}


x86 assembly (clang, -O0):
<kalman>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1040 <fmean@plt>
movss  %xmm0,-0x20(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1201 <kalman+0xb1>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    11c7 <kalman+0x77>
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  0xe4b(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    11ee <kalman+0x9e>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  0xe1b(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    11f3 <kalman+0xa3>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1188 <kalman+0x38>
movss  0xdf7(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1060 <fmini@plt>
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1070 <fmaxi@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1060 <fmini@plt>
mov    %eax,%ecx
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x58(%rbp),%eax
add    %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1070 <fmaxi@plt>
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1060 <fmini@plt>
mov    %eax,%ecx
mov    -0x54(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1070 <fmaxi@plt>
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1060 <fmini@plt>
mov    -0x50(%rbp),%ecx
mov    %eax,%edx
mov    -0x4c(%rbp),%eax
sub    %edx,%ecx
imul   %ecx,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm1
divss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x30(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm1
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13fe <kalman+0x2ae>
movss  -0x34(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm2
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1337 <kalman+0x1e7>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     14ef <kalman+0x39f>
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
addss  -0x34(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1407 <kalman+0x2b7>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    152a <kalman+0x3da>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14f6 <kalman+0x3a6>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kalman>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r15d
mov    %rdi,%r12
call   1040 <fmean@plt>
movss  %xmm0,(%rsp)
mov    %r15d,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
movss  (%rsp),%xmm5
mov    %rax,%r14
mov    %r15d,%r13d
test   %r15d,%r15d
jle    1318 <kalman+0x1c8>
cmp    $0x8,%r15d
jb     11a4 <kalman+0x54>
lea    (%r14,%r13,4),%rax
cmp    %r12,%rax
jbe    11d5 <kalman+0x85>
lea    (%r12,%r13,4),%rax
cmp    %rax,%r14
jae    11d5 <kalman+0x85>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r13b
je     130f <kalman+0x1bf>
movss  (%r12,%rax,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    12f7 <kalman+0x1a7>
movss  0xe50(%rip),%xmm0
jmp    1305 <kalman+0x1b5>
mov    %r13d,%eax
and    $0xfffffff8,%eax
lea    0x0(,%r13,4),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edx,%edx
movaps 0xe10(%rip),%xmm0
movaps 0xe19(%rip),%xmm1
jmp    123e <kalman+0xee>
nopl   0x0(%rax)
xorps  %xmm4,%xmm4
cmpltps %xmm3,%xmm4
xorps  %xmm3,%xmm3
cmpltps %xmm2,%xmm3
movaps %xmm1,%xmm2
andps  %xmm3,%xmm2
andnps %xmm0,%xmm3
orps   %xmm2,%xmm3
movaps %xmm1,%xmm2
andps  %xmm4,%xmm2
andnps %xmm0,%xmm4
orps   %xmm2,%xmm4
movups %xmm3,(%r14,%rdx,1)
movups %xmm4,0x10(%r14,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rcx
je     12ed <kalman+0x19d>
movups (%r12,%rdx,1),%xmm2
xorps  %xmm3,%xmm3
cmpnltps %xmm2,%xmm3
movd   %xmm3,%esi
test   $0x1,%sil
je     125a <kalman+0x10a>
movss  %xmm5,(%r12,%rdx,1)
pextrw $0x2,%xmm3,%esi
test   $0x1,%sil
je     126c <kalman+0x11c>
movss  %xmm5,0x4(%r12,%rdx,1)
pextrw $0x4,%xmm3,%esi
test   $0x1,%sil
je     127e <kalman+0x12e>
movss  %xmm5,0x8(%r12,%rdx,1)
pextrw $0x6,%xmm3,%esi
test   $0x1,%sil
je     1290 <kalman+0x140>
movss  %xmm5,0xc(%r12,%rdx,1)
movups 0x10(%r12,%rdx,1),%xmm3
xorps  %xmm4,%xmm4
cmpnltps %xmm3,%xmm4
movd   %xmm4,%esi
test   $0x1,%sil
je     12ae <kalman+0x15e>
movss  %xmm5,0x10(%r12,%rdx,1)
pextrw $0x2,%xmm4,%esi
test   $0x1,%sil
je     12c0 <kalman+0x170>
movss  %xmm5,0x14(%r12,%rdx,1)
pextrw $0x4,%xmm4,%esi
test   $0x1,%sil
je     12d2 <kalman+0x182>
movss  %xmm5,0x18(%r12,%rdx,1)
pextrw $0x6,%xmm4,%esi
test   $0x1,%sil
je     1200 <kalman+0xb0>
movss  %xmm5,0x1c(%r12,%rdx,1)
jmp    1200 <kalman+0xb0>
cmp    %r13,%rax
je     1318 <kalman+0x1c8>
jmp    11a6 <kalman+0x56>
movss  %xmm5,(%r12,%rax,4)
movss  0xd1f(%rip),%xmm0
movss  %xmm0,(%r14,%rax,4)
or     $0x1,%rax
add    %r13,%rcx
jne    149a <kalman+0x34a>
mov    %r12,%rdi
mov    %r15d,%esi
call   1060 <fmini@plt>
mov    %eax,%ebx
mov    %r12,%rdi
mov    %r15d,%esi
call   1070 <fmaxi@plt>
mov    %eax,%ebp
mov    %r12,%rdi
mov    %r15d,%esi
call   1060 <fmini@plt>
sub    %eax,%ebp
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
sar    %eax
add    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rsp)
mov    %r12,%rdi
mov    %r15d,%esi
call   1070 <fmaxi@plt>
mov    %eax,%ebx
mov    %r12,%rdi
mov    %r15d,%esi
call   1060 <fmini@plt>
sub    %eax,%ebx
mov    %r12,%rdi
mov    %r15d,%esi
call   1070 <fmaxi@plt>
mov    %eax,%ebp
mov    %r12,%rdi
mov    %r15d,%esi
call   1060 <fmini@plt>
sub    %eax,%ebp
imul   %ebx,%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
movss  %xmm0,0x4(%rsp)
mov    %r15d,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rbx
mov    %r15d,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
movss  (%r14),%xmm0
movss  (%rsp),%xmm2
mulss  %xmm0,%xmm2
movss  (%r12),%xmm1
movss  0x4(%rsp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
addss  %xmm3,%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,(%rbx)
movss  (%r14),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm3,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
cmp    $0x2,%r15d
jl     15dc <kalman+0x48c>
lea    (%rax,%r13,4),%rcx
cmp    %rcx,%rbx
jae    14fc <kalman+0x3ac>
lea    (%rbx,%r13,4),%rcx
mov    %rax,%rdx
add    $0x4,%rdx
cmp    %rcx,%rdx
jae    14fc <kalman+0x3ac>
mov    $0x1,%ecx
movss  0xbf3(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
addss  %xmm1,%xmm0
movss  (%r14,%rcx,4),%xmm2
movss  -0x4(%rbx,%rcx,4),%xmm3
mulss  %xmm2,%xmm3
movss  (%r12,%rcx,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
addss  %xmm0,%xmm2
divss  %xmm2,%xmm4
movss  %xmm4,(%rbx,%rcx,4)
movss  (%r14,%rcx,4),%xmm2
movaps %xmm0,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm2,%xmm0
divss  %xmm0,%xmm3
movss  %xmm3,(%rax,%rcx,4)
add    $0x1,%rcx
movaps %xmm3,%xmm0
cmp    %rcx,%r13
jne    1440 <kalman+0x2f0>
jmp    1562 <kalman+0x412>
movss  0xb7e(%rip),%xmm0
xorps  %xmm1,%xmm1
movss  0xb77(%rip),%xmm2
jmp    14c4 <kalman+0x374>
nop
movss  %xmm3,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %rax,%r13
je     1318 <kalman+0x1c8>
movss  (%r12,%rax,4),%xmm3
ucomiss %xmm1,%xmm3
movaps %xmm0,%xmm3
ja     14db <kalman+0x38b>
movss  %xmm5,(%r12,%rax,4)
movaps %xmm2,%xmm3
movss  %xmm3,(%r14,%rax,4)
movss  0x4(%r12,%rax,4),%xmm3
ucomiss %xmm1,%xmm3
movaps %xmm0,%xmm3
ja     14b0 <kalman+0x360>
movss  %xmm5,0x4(%r12,%rax,4)
movaps %xmm2,%xmm3
jmp    14b0 <kalman+0x360>
movss  (%rbx),%xmm2
mov    $0x1,%ecx
movss  0xb1b(%rip),%xmm1
nopl   (%rax)
addss  %xmm1,%xmm0
movss  (%r14,%rcx,4),%xmm3
mulss  %xmm3,%xmm2
movss  (%r12,%rcx,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm2,%xmm4
addss  %xmm0,%xmm3
divss  %xmm3,%xmm4
movss  %xmm4,(%rbx,%rcx,4)
movss  (%r14,%rcx,4),%xmm2
movaps %xmm0,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm2,%xmm0
divss  %xmm0,%xmm3
movss  %xmm3,(%rax,%rcx,4)
add    $0x1,%rcx
movaps %xmm4,%xmm2
movaps %xmm3,%xmm0
cmp    %rcx,%r13
jne    1510 <kalman+0x3c0>
cmp    $0x2,%r15d
jl     15dc <kalman+0x48c>
lea    -0x2(%r15),%ecx
movss  0xab4(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x4(%rbx,%rcx,4),%xmm1
movss  (%rbx,%rcx,4),%xmm2
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm0,%xmm2
addss  %xmm2,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
movss  (%rax,%rcx,4),%xmm2
addss  %xmm0,%xmm2
divss  %xmm2,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
movss  (%rax,%rcx,4),%xmm1
movaps %xmm1,%xmm2
addss  %xmm0,%xmm2
divss  %xmm2,%xmm1
movss  0x4(%rax,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,(%rax,%rcx,4)
add    $0xffffffffffffffff,%rcx
jb     1580 <kalman+0x430>
test   %r15d,%r15d
jle    1754 <kalman+0x604>
cmp    $0x8,%r15d
jb     1605 <kalman+0x4b5>
lea    (%rbx,%r13,4),%rcx
cmp    %r12,%rcx
jbe    1680 <kalman+0x530>
lea    (%r12,%r13,4),%rcx
cmp    %rcx,%rbx
jae    1680 <kalman+0x530>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r13,%rdx
mov    %r13,%rsi
and    $0x3,%rsi
je     1635 <kalman+0x4e5>
nopl   0x0(%rax)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1620 <kalman+0x4d0>
cmp    $0x3,%rdx
jb     1754 <kalman+0x604>
nop
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%r12,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%r12,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%r12,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    1640 <kalman+0x4f0>
jmp    1754 <kalman+0x604>
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    16a4 <kalman+0x554>
xor    %edi,%edi
jmp    1710 <kalman+0x5c0>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,(%r12,%rdi,4)
movups %xmm1,0x10(%r12,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x20(%r12,%rdi,4)
movups %xmm1,0x30(%r12,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x40(%r12,%rdi,4)
movups %xmm1,0x50(%r12,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x60(%r12,%rdi,4)
movups %xmm1,0x70(%r12,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    16b0 <kalman+0x560>
test   %rdx,%rdx
je     174b <kalman+0x5fb>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1730 <kalman+0x5e0>
cmp    %r13,%rcx
jne    1607 <kalman+0x4b7>
mov    %rax,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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