#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 */
typedef size_t int32_t;

/* Variables and functions */
void lpfilt(float inbuf[], float lpbuf[], int32_t len, int32_t nsamp) {
  int32_t j;
  float t;
  for (j = len - nsamp; j < len; j++) {
    t = (inbuf[j] + inbuf[j - 30]) * -0.0097201988f;
    t += (inbuf[j - 1] + inbuf[j - 29]) * -0.0105179986f;
    t += (inbuf[j - 2] + inbuf[j - 28]) * -0.0083479648f;
    t += (inbuf[j - 3] + inbuf[j - 27]) * 5.860774e-4f;
    t += (inbuf[j - 4] + inbuf[j - 26]) * 0.0130892089f;
    t += (inbuf[j - 5] + inbuf[j - 25]) * 0.0217052232f;
    t += (inbuf[j - 6] + inbuf[j - 24]) * 0.0184161253f;
    t += (inbuf[j - 7] + inbuf[j - 23]) * 3.39723e-4f;
    t += (inbuf[j - 8] + inbuf[j - 22]) * -0.0260797087f;
    t += (inbuf[j - 9] + inbuf[j - 21]) * -0.0455563702f;
    t += (inbuf[j - 10] + inbuf[j - 20]) * -0.040306855f;
    t += (inbuf[j - 11] + inbuf[j - 19]) * 5.029835e-4f;
    t += (inbuf[j - 12] + inbuf[j - 18]) * 0.0729262903f;
    t += (inbuf[j - 13] + inbuf[j - 17]) * 0.1572008878f;
    t += (inbuf[j - 14] + inbuf[j - 16]) * 0.2247288674f;
    t += inbuf[j - 15] * 0.250535965f;
    lpbuf[j] = t;
  }
}


x86 assembly (clang, -O0):
<lpfilt>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    14f3 <lpfilt+0x3f3>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1e,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xee8(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1d,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xeac(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x2,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1c,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xe6c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x3,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1b,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xe2c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x4,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1a,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xdec(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x5,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x19,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xdac(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x6,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x18,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xd6c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x7,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x17,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xd2c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x8,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x16,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xcec(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x9,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x15,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xcac(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0xa,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x14,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xc6c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0xb,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x13,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xc2c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0xc,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x12,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xbec(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0xd,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x11,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xbac(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0xe,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x10,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xb6c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0xf,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xb3d(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1120 <lpfilt+0x20>
pop    %rbp
ret

x86 assembly (clang, -O2):
<lpfilt>:
push   %rbx
mov    %rdx,%rbx
sub    %rcx,%rbx
cmp    %rdx,%rbx
jae    14e9 <lpfilt+0x3e9>
cmp    $0x4,%rcx
jb     131b <lpfilt+0x21b>
lea    (%rsi,%rbx,4),%r8
lea    (%rdi,%rdx,4),%rax
cmp    %rax,%r8
jae    113c <lpfilt+0x3c>
lea    (%rsi,%rdx,4),%r9
lea    (%rdi,%rbx,4),%rax
add    $0xffffffffffffff88,%rax
cmp    %r9,%rax
jb     131b <lpfilt+0x21b>
mov    %rcx,%r9
and    $0xfffffffffffffffc,%r9
lea    (%rdi,%rbx,4),%r10
add    %r9,%rbx
xor    %r11d,%r11d
movaps 0xefb(%rip),%xmm13
movaps 0xf03(%rip),%xmm14
movaps 0xf0b(%rip),%xmm15
movaps 0xf13(%rip),%xmm10
movaps 0xf1b(%rip),%xmm11
movaps 0xf23(%rip),%xmm12
movaps 0xf2c(%rip),%xmm3
movaps 0xf35(%rip),%xmm4
movaps 0xf3e(%rip),%xmm5
movaps 0xf47(%rip),%xmm6
movaps 0xf50(%rip),%xmm7
movups (%r10,%r11,4),%xmm8
movups -0x78(%r10,%r11,4),%xmm9
addps  %xmm8,%xmm9
movups -0x74(%r10,%r11,4),%xmm0
movups -0x4(%r10,%r11,4),%xmm1
addps  %xmm0,%xmm1
movups -0x70(%r10,%r11,4),%xmm0
mulps  0xe34(%rip),%xmm9
mulps  0xe3d(%rip),%xmm1
addps  %xmm9,%xmm1
movups -0x8(%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
movups -0x6c(%r10,%r11,4),%xmm0
mulps  0xe33(%rip),%xmm2
addps  %xmm1,%xmm2
movups -0xc(%r10,%r11,4),%xmm1
addps  %xmm0,%xmm1
mulps  0xe30(%rip),%xmm1
addps  %xmm2,%xmm1
movups -0x10(%r10,%r11,4),%xmm0
movups -0x68(%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
mulps  0xe27(%rip),%xmm2
addps  %xmm1,%xmm2
movups -0x14(%r10,%r11,4),%xmm0
movups -0x64(%r10,%r11,4),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm13,%xmm1
addps  %xmm2,%xmm1
movups -0x18(%r10,%r11,4),%xmm0
movups -0x60(%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
mulps  %xmm14,%xmm2
addps  %xmm1,%xmm2
movups -0x1c(%r10,%r11,4),%xmm0
movups -0x5c(%r10,%r11,4),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm15,%xmm1
addps  %xmm2,%xmm1
movups -0x20(%r10,%r11,4),%xmm0
movups -0x58(%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
mulps  %xmm10,%xmm2
addps  %xmm1,%xmm2
movups -0x24(%r10,%r11,4),%xmm0
movups -0x54(%r10,%r11,4),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm11,%xmm1
addps  %xmm2,%xmm1
movups -0x28(%r10,%r11,4),%xmm0
movups -0x50(%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
mulps  %xmm12,%xmm2
addps  %xmm1,%xmm2
movups -0x2c(%r10,%r11,4),%xmm0
movups -0x4c(%r10,%r11,4),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm2,%xmm1
movups -0x30(%r10,%r11,4),%xmm0
movups -0x48(%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm1,%xmm2
movups -0x34(%r10,%r11,4),%xmm0
movups -0x44(%r10,%r11,4),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm5,%xmm1
addps  %xmm2,%xmm1
movups -0x38(%r10,%r11,4),%xmm0
movups -0x40(%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
mulps  %xmm6,%xmm2
addps  %xmm1,%xmm2
movups -0x3c(%r10,%r11,4),%xmm0
mulps  %xmm7,%xmm0
addps  %xmm2,%xmm0
movups %xmm0,(%r8,%r11,4)
add    $0x4,%r11
cmp    %r11,%r9
jne    11a0 <lpfilt+0xa0>
cmp    %rcx,%r9
je     14e9 <lpfilt+0x3e9>
movss  0xdf0(%rip),%xmm13
movss  0xdeb(%rip),%xmm14
movss  0xde6(%rip),%xmm15
movss  0xde1(%rip),%xmm10
movss  0xddc(%rip),%xmm11
movss  0xdd7(%rip),%xmm12
movss  0xdd3(%rip),%xmm3
movss  0xdcf(%rip),%xmm4
movss  0xdcb(%rip),%xmm5
movss  0xdc7(%rip),%xmm6
movss  0xdc3(%rip),%xmm7
nopl   0x0(%rax)
movss  (%rdi,%rbx,4),%xmm8
addss  -0x78(%rdi,%rbx,4),%xmm8
mulss  0xd6a(%rip),%xmm8
movss  -0x4(%rdi,%rbx,4),%xmm9
addss  -0x74(%rdi,%rbx,4),%xmm9
mulss  0xd57(%rip),%xmm9
addss  %xmm8,%xmm9
movss  -0x8(%rdi,%rbx,4),%xmm0
addss  -0x70(%rdi,%rbx,4),%xmm0
mulss  0xd42(%rip),%xmm0
movss  -0xc(%rdi,%rbx,4),%xmm1
addss  -0x6c(%rdi,%rbx,4),%xmm1
addss  %xmm9,%xmm0
mulss  0xd2d(%rip),%xmm1
addss  %xmm0,%xmm1
movss  -0x10(%rdi,%rbx,4),%xmm0
addss  -0x68(%rdi,%rbx,4),%xmm0
mulss  0xd19(%rip),%xmm0
addss  %xmm1,%xmm0
movss  -0x14(%rdi,%rbx,4),%xmm1
addss  -0x64(%rdi,%rbx,4),%xmm1
mulss  %xmm13,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rdi,%rbx,4),%xmm0
addss  -0x60(%rdi,%rbx,4),%xmm0
mulss  %xmm14,%xmm0
movss  -0x1c(%rdi,%rbx,4),%xmm2
addss  -0x5c(%rdi,%rbx,4),%xmm2
addss  %xmm1,%xmm0
mulss  %xmm15,%xmm2
addss  %xmm0,%xmm2
movss  -0x20(%rdi,%rbx,4),%xmm0
addss  -0x58(%rdi,%rbx,4),%xmm0
mulss  %xmm10,%xmm0
addss  %xmm2,%xmm0
movss  -0x24(%rdi,%rbx,4),%xmm1
addss  -0x54(%rdi,%rbx,4),%xmm1
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rdi,%rbx,4),%xmm0
addss  -0x50(%rdi,%rbx,4),%xmm0
mulss  %xmm12,%xmm0
movss  -0x2c(%rdi,%rbx,4),%xmm2
addss  -0x4c(%rdi,%rbx,4),%xmm2
addss  %xmm1,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
movss  -0x30(%rdi,%rbx,4),%xmm0
addss  -0x48(%rdi,%rbx,4),%xmm0
mulss  %xmm4,%xmm0
addss  %xmm2,%xmm0
movss  -0x34(%rdi,%rbx,4),%xmm1
addss  -0x44(%rdi,%rbx,4),%xmm1
mulss  %xmm5,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rdi,%rbx,4),%xmm0
addss  -0x40(%rdi,%rbx,4),%xmm0
mulss  %xmm6,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rdi,%rbx,4),%xmm1
mulss  %xmm7,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1380 <lpfilt+0x280>
pop    %rbx
ret

LLVM IR (-O0):
define void @lpfilt(float* %0, float* %1, i64 %2, i64 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca float
store float* %0, float** %5
store float* %1, float** %6
store i64 %2, i64* %7
store i64 %3, i64* %8
%11 = load i64, i64* %7
%12 = load i64, i64* %8
%13 = sub i64 %11, %12
store i64 %13, i64* %9
br label %14
14: ; preds = %223, %4
%15 = load i64, i64* %9
%16 = load i64, i64* %7
%17 = icmp ult i64 %15, %16
br i1 %17, label %18, label %226
18: ; preds = %14
%19 = load float*, float** %5
%20 = load i64, i64* %9
%21 = getelementptr inbounds float, float* %19, i64 %20
%22 = load float, float* %21
%23 = load float*, float** %5
%24 = load i64, i64* %9
%25 = sub i64 %24, 30
%26 = getelementptr inbounds float, float* %23, i64 %25
%27 = load float, float* %26
%28 = fadd float %22, %27
%29 = fmul float %28, 0xBF83E82F00000000
store float %29, float* %10
%30 = load float*, float** %5
%31 = load i64, i64* %9
%32 = sub i64 %31, 1
%33 = getelementptr inbounds float, float* %30, i64 %32
%34 = load float, float* %33
%35 = load float*, float** %5
%36 = load i64, i64* %9
%37 = sub i64 %36, 29
%38 = getelementptr inbounds float, float* %35, i64 %37
%39 = load float, float* %38
%40 = fadd float %34, %39
%41 = load float, float* %10
%42 = call float @llvm.fmuladd.f32(float %40, float 0xBF858A75E0000000, float %41)
store float %42, float* %10
%43 = load float*, float** %5
%44 = load i64, i64* %9
%45 = sub i64 %44, 2
%46 = getelementptr inbounds float, float* %43, i64 %45
%47 = load float, float* %46
%48 = load float*, float** %5
%49 = load i64, i64* %9
%50 = sub i64 %49, 28
%51 = getelementptr inbounds float, float* %48, i64 %50
%52 = load float, float* %51
%53 = fadd float %47, %52
%54 = load float, float* %10
%55 = call float @llvm.fmuladd.f32(float %53, float 0xBF8118BCE0000000, float %54)
store float %55, float* %10
%56 = load float*, float** %5
%57 = load i64, i64* %9
%58 = sub i64 %57, 3
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
%61 = load float*, float** %5
%62 = load i64, i64* %9
%63 = sub i64 %62, 27
%64 = getelementptr inbounds float, float* %61, i64 %63
%65 = load float, float* %64
%66 = fadd float %60, %65
%67 = load float, float* %10
%68 = call float @llvm.fmuladd.f32(float %66, float 0x3F43345FA0000000, float %67)
store float %68, float* %10
%69 = load float*, float** %5
%70 = load i64, i64* %9
%71 = sub i64 %70, 4
%72 = getelementptr inbounds float, float* %69, i64 %71
%73 = load float, float* %72
%74 = load float*, float** %5
%75 = load i64, i64* %9
%76 = sub i64 %75, 26
%77 = getelementptr inbounds float, float* %74, i64 %76
%78 = load float, float* %77
%79 = fadd float %73, %78
%80 = load float, float* %10
%81 = call float @llvm.fmuladd.f32(float %79, float 0x3F8ACE83E0000000, float %80)
store float %81, float* %10
%82 = load float*, float** %5
%83 = load i64, i64* %9
%84 = sub i64 %83, 5
%85 = getelementptr inbounds float, float* %82, i64 %84
%86 = load float, float* %85
%87 = load float*, float** %5
%88 = load i64, i64* %9
%89 = sub i64 %88, 25
%90 = getelementptr inbounds float, float* %87, i64 %89
%91 = load float, float* %90
%92 = fadd float %86, %91
%93 = load float, float* %10
%94 = call float @llvm.fmuladd.f32(float %92, float 0x3F9639E4E0000000, float %93)
store float %94, float* %10
%95 = load float*, float** %5
%96 = load i64, i64* %9
%97 = sub i64 %96, 6
%98 = getelementptr inbounds float, float* %95, i64 %97
%99 = load float, float* %98
%100 = load float*, float** %5
%101 = load i64, i64* %9
%102 = sub i64 %101, 24
%103 = getelementptr inbounds float, float* %100, i64 %102
%104 = load float, float* %103
%105 = fadd float %99, %104
%106 = load float, float* %10
%107 = call float @llvm.fmuladd.f32(float %105, float 0x3F92DBAD40000000, float %106)
store float %107, float* %10
%108 = load float*, float** %5
%109 = load i64, i64* %9
%110 = sub i64 %109, 7
%111 = getelementptr inbounds float, float* %108, i64 %110
%112 = load float, float* %111
%113 = load float*, float** %5
%114 = load i64, i64* %9
%115 = sub i64 %114, 23
%116 = getelementptr inbounds float, float* %113, i64 %115
%117 = load float, float* %116
%118 = fadd float %112, %117
%119 = load float, float* %10
%120 = call float @llvm.fmuladd.f32(float %118, float 0x3F36439B20000000, float %119)
store float %120, float* %10
%121 = load float*, float** %5
%122 = load i64, i64* %9
%123 = sub i64 %122, 8
%124 = getelementptr inbounds float, float* %121, i64 %123
%125 = load float, float* %124
%126 = load float*, float** %5
%127 = load i64, i64* %9
%128 = sub i64 %127, 22
%129 = getelementptr inbounds float, float* %126, i64 %128
%130 = load float, float* %129
%131 = fadd float %125, %130
%132 = load float, float* %10
%133 = call float @llvm.fmuladd.f32(float %131, float 0xBF9AB4A3A0000000, float %132)
store float %133, float* %10
%134 = load float*, float** %5
%135 = load i64, i64* %9
%136 = sub i64 %135, 9
%137 = getelementptr inbounds float, float* %134, i64 %136
%138 = load float, float* %137
%139 = load float*, float** %5
%140 = load i64, i64* %9
%141 = sub i64 %140, 21
%142 = getelementptr inbounds float, float* %139, i64 %141
%143 = load float, float* %142
%144 = fadd float %138, %143
%145 = load float, float* %10
%146 = call float @llvm.fmuladd.f32(float %144, float 0xBFA7532A20000000, float %145)
store float %146, float* %10
%147 = load float*, float** %5
%148 = load i64, i64* %9
%149 = sub i64 %148, 10
%150 = getelementptr inbounds float, float* %147, i64 %149
%151 = load float, float* %150
%152 = load float*, float** %5
%153 = load i64, i64* %9
%154 = sub i64 %153, 20
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = fadd float %151, %156
%158 = load float, float* %10
%159 = call float @llvm.fmuladd.f32(float %157, float 0xBFA4A319A0000000, float %158)
store float %159, float* %10
%160 = load float*, float** %5
%161 = load i64, i64* %9
%162 = sub i64 %161, 11
%163 = getelementptr inbounds float, float* %160, i64 %162
%164 = load float, float* %163
%165 = load float*, float** %5
%166 = load i64, i64* %9
%167 = sub i64 %166, 19
%168 = getelementptr inbounds float, float* %165, i64 %167
%169 = load float, float* %168
%170 = fadd float %164, %169
%171 = load float, float* %10
%172 = call float @llvm.fmuladd.f32(float %170, float 0x3F407B54E0000000, float %171)
store float %172, float* %10
%173 = load float*, float** %5
%174 = load i64, i64* %9
%175 = sub i64 %174, 12
%176 = getelementptr inbounds float, float* %173, i64 %175
%177 = load float, float* %176
%178 = load float*, float** %5
%179 = load i64, i64* %9
%180 = sub i64 %179, 18
%181 = getelementptr inbounds float, float* %178, i64 %180
%182 = load float, float* %181
%183 = fadd float %177, %182
%184 = load float, float* %10
%185 = call float @llvm.fmuladd.f32(float %183, float 0x3FB2AB4C20000000, float %184)
store float %185, float* %10
%186 = load float*, float** %5
%187 = load i64, i64* %9
%188 = sub i64 %187, 13
%189 = getelementptr inbounds float, float* %186, i64 %188
%190 = load float, float* %189
%191 = load float*, float** %5
%192 = load i64, i64* %9
%193 = sub i64 %192, 17
%194 = getelementptr inbounds float, float* %191, i64 %193
%195 = load float, float* %194
%196 = fadd float %190, %195
%197 = load float, float* %10
%198 = call float @llvm.fmuladd.f32(float %196, float 0x3FC41F28A0000000, float %197)
store float %198, float* %10
%199 = load float*, float** %5
%200 = load i64, i64* %9
%201 = sub i64 %200, 14
%202 = getelementptr inbounds float, float* %199, i64 %201
%203 = load float, float* %202
%204 = load float*, float** %5
%205 = load i64, i64* %9
%206 = sub i64 %205, 16
%207 = getelementptr inbounds float, float* %204, i64 %206
%208 = load float, float* %207
%209 = fadd float %203, %208
%210 = load float, float* %10
%211 = call float @llvm.fmuladd.f32(float %209, float 0x3FCCC3EA60000000, float %210)
store float %211, float* %10
%212 = load float*, float** %5
%213 = load i64, i64* %9
%214 = sub i64 %213, 15
%215 = getelementptr inbounds float, float* %212, i64 %214
%216 = load float, float* %215
%217 = load float, float* %10
%218 = call float @llvm.fmuladd.f32(float %216, float 0x3FD008C800000000, float %217)
store float %218, float* %10
%219 = load float, float* %10
%220 = load float*, float** %6
%221 = load i64, i64* %9
%222 = getelementptr inbounds float, float* %220, i64 %221
store float %219, float* %222
br label %223
223: ; preds = %18
%224 = load i64, i64* %9
%225 = add i64 %224, 1
store i64 %225, i64* %9
br label %14
226: ; preds = %14
ret void
}

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