#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__ cos(int);
double fabs(float);
scalar_t__ sqrt(float);
void smath(float *odata, float *sseq, int hl, float alpha0) {
  int i, k;
  float w00, w10, w11, A, B, C, *psseq, err, errs;
  float surround[240];
  float wt[2 * 3 + 1];
  float denom;
  for (i = 1; i <= 2 * hl + 1; i++) {
    wt[i - 1] =
        (float)0.5 *
        (1 - (float)cos(2 * (float)3.14159265358979323846 * i / (2 * hl + 2)));
  }
  wt[hl] = 0.0;
  for (i = 0; i < 80; i++) {
    surround[i] = sseq[i] * wt[0];
  }
  for (k = 1; k < hl; k++) {
    psseq = sseq + k * 80;
    for (i = 0; i < 80; i++) {
      surround[i] += psseq[i] * wt[k];
    }
  }
  for (k = hl + 1; k <= 2 * hl; k++) {
    psseq = sseq + k * 80;
    for (i = 0; i < 80; i++) {
      surround[i] += psseq[i] * wt[k];
    }
  }
  w00 = w10 = w11 = 0.0;
  psseq = sseq + hl * 80;
  for (i = 0; i < 80; i++) {
    w00 += psseq[i] * psseq[i];
    w11 += surround[i] * surround[i];
    w10 += surround[i] * psseq[i];
  }
  if (fabs(w11) < 1.0) {
    w11 = 1.0;
  }
  C = (float)sqrt(w00 / w11);
  errs = 0.0;
  psseq = sseq + hl * 80;
  for (i = 0; i < 80; i++) {
    odata[i] = C * surround[i];
    err = psseq[i] - odata[i];
    errs += err * err;
  }
  if (errs > alpha0 * w00) {
    if (w00 < 1) {
      w00 = 1;
    }
    denom = (w11 * w00 - w10 * w10) / (w00 * w00);
    if (denom > 0.0001) {
      A = (float)sqrt((alpha0 - alpha0 * alpha0 / 4) / denom);
      B = -alpha0 / 2 - A * w10 / w00;
      B = B + 1;
    } else {
      A = 0.0;
      B = 1.0;
    }
    psseq = sseq + hl * 80;
    for (i = 0; i < 80; i++) {
      odata[i] = A * surround[i] + B * psseq[i];
    }
  }
}


x86 assembly (clang, -O0):
<smath>:
push   %rbp
mov    %rsp,%rbp
sub    $0x440,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     11cd <smath+0x9d>
cvtsi2ssl -0x1c(%rbp),%xmm1
movss  0xead(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm0
movss  0xe72(%rip),%xmm1
subss  %xmm0,%xmm1
movss  0xe72(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  %xmm0,-0x430(%rbp,%rax,4)
ff ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1152 <smath+0x22>
movslq -0x14(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x430(%rbp,%rax,4)
ff ff
movl   $0x0,-0x1c(%rbp)
cmpl   $0x50,-0x1c(%rbp)
jge    121e <smath+0xee>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x430(%rbp),%xmm0
ff
movslq -0x1c(%rbp),%rax
movss  %xmm0,-0x410(%rbp,%rax,4)
ff ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e4 <smath+0xb4>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b1 <smath+0x181>
mov    -0x10(%rbp),%rax
imul   $0x50,-0x20(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x50,-0x1c(%rbp)
jge    129e <smath+0x16e>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x20(%rbp),%rax
movss  -0x430(%rbp,%rax,4),%xmm2
ff ff
movslq -0x1c(%rbp),%rax
movss  -0x410(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x410(%rbp,%rax,4)
ff ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    124e <smath+0x11e>
jmp    12a3 <smath+0x173>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1225 <smath+0xf5>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     134b <smath+0x21b>
mov    -0x10(%rbp),%rax
imul   $0x50,-0x20(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x50,-0x1c(%rbp)
jge    1338 <smath+0x208>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x20(%rbp),%rax
movss  -0x430(%rbp,%rax,4),%xmm2
ff ff
movslq -0x1c(%rbp),%rax
movss  -0x410(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x410(%rbp,%rax,4)
ff ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12e8 <smath+0x1b8>
jmp    133d <smath+0x20d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12ba <smath+0x18a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x50,-0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x50,-0x1c(%rbp)
jge    141c <smath+0x2ec>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movslq -0x1c(%rbp),%rax
movss  -0x410(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1c(%rbp),%rax
movss  -0x410(%rbp,%rax,4),%xmm2
ff ff
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movslq -0x1c(%rbp),%rax
movss  -0x410(%rbp,%rax,4),%xmm0
ff ff
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1380 <smath+0x250>
movss  -0x2c(%rbp),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xbcf(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1448 <smath+0x318>
movss  0xbcd(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x24(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
call   1050 <sqrt@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x50,-0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x50,-0x1c(%rbp)
jge    14f8 <smath+0x3c8>
movss  -0x38(%rbp),%xmm0
movslq -0x1c(%rbp),%rax
mulss  -0x410(%rbp,%rax,4),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1486 <smath+0x356>
movss  -0x48(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1697 <smath+0x567>
movss  0xaf8(%rip),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    152f <smath+0x3ff>
movss  0xae6(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x434(%rbp)
ff
movss  -0x434(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xa86(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    160f <smath+0x4df>
movss  -0x18(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movss  0xa75(%rip),%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
divss  -0x434(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  0xa38(%rip),%xmm1
divss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
divss  -0x24(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xa10(%rip),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1624 <smath+0x4f4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  0x9f1(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x50,-0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x50,-0x1c(%rbp)
jge    1692 <smath+0x562>
movss  -0x30(%rbp),%xmm0
movslq -0x1c(%rbp),%rax
movss  -0x410(%rbp,%rax,4),%xmm2
ff ff
movss  -0x34(%rbp),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1641 <smath+0x511>
jmp    1697 <smath+0x567>
add    $0x440,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<smath>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x468,%rsp
movss  %xmm0,0xc(%rsp)
mov    %edx,%r15d
mov    %rsi,%r14
mov    %rdi,%r12
lea    (%r15,%r15,1),%r13d
lea    (%r15,%r15,1),%eax
add    $0x1,%eax
test   %eax,%eax
jle    11c9 <smath+0x99>
lea    0x2(%r13),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
movss  %xmm0,0x10(%rsp)
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  0xe71(%rip),%xmm0
divss  0x10(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0xe56(%rip),%xmm1
subss  %xmm0,%xmm1
mulss  0xe4e(%rip),%xmm1
movss  %xmm1,0x7c(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1180 <smath+0x50>
movslq %r15d,%rax
movl   $0x0,0x80(%rsp,%rax,4)
movaps 0x80(%rsp),%xmm0
shufps $0x0,%xmm0,%xmm0
movups (%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xa0(%rsp)
movups 0x10(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xb0(%rsp)
movups 0x20(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xc0(%rsp)
movups 0x30(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xd0(%rsp)
movups 0x40(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xe0(%rsp)
movups 0x50(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xf0(%rsp)
movups 0x60(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x100(%rsp)
movups 0x70(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x110(%rsp)
movups 0x80(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x120(%rsp)
movups 0x90(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x130(%rsp)
movups 0xa0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x140(%rsp)
movups 0xb0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x150(%rsp)
movups 0xc0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x160(%rsp)
movups 0xd0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x170(%rsp)
movups 0xe0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x180(%rsp)
movups 0xf0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x190(%rsp)
movups 0x100(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1a0(%rsp)
movups 0x110(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1b0(%rsp)
movups 0x120(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1c0(%rsp)
movups 0x130(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1d0(%rsp)
cmp    $0x2,%r15d
jl     165d <smath+0x52d>
mov    %r15d,%ecx
movaps 0xa0(%rsp),%xmm8
movaps 0xb0(%rsp),%xmm7
movaps 0xc0(%rsp),%xmm10
movaps 0xd0(%rsp),%xmm12
movaps 0xe0(%rsp),%xmm11
movaps 0xf0(%rsp),%xmm9
movaps 0x100(%rsp),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0x110(%rsp),%xmm15
movaps 0x120(%rsp),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0x130(%rsp),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x140(%rsp),%xmm3
movaps 0x150(%rsp),%xmm2
movaps 0x160(%rsp),%xmm1
movaps 0x170(%rsp),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x180(%rsp),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0x190(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0x270(%r14),%rdx
mov    $0x1,%esi
movaps 0x1a0(%rsp),%xmm6
movaps 0x1b0(%rsp),%xmm13
movaps 0x1c0(%rsp),%xmm14
movaps 0x1d0(%rsp),%xmm5
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm5,0x10(%rsp)
movss  0x80(%rsp,%rsi,4),%xmm4
shufps $0x0,%xmm4,%xmm4
movups -0x130(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm8
movups -0x120(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm7
movups -0x110(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm10
movups -0x100(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm12
movups -0xf0(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm11
movups -0xe0(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm9
movups -0xd0(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x40(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x40(%rsp)
movups -0xc0(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm15
movups -0xb0(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x60(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x60(%rsp)
movups -0xa0(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x50(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x50(%rsp)
movups -0x90(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm3
movups -0x80(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm2
movups -0x70(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm1
movups -0x60(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x70(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x70(%rsp)
movups -0x50(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x30(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x30(%rsp)
movups -0x40(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps %xmm6,%xmm0
movaps 0x20(%rsp),%xmm6
addps  %xmm5,%xmm6
movaps %xmm6,0x20(%rsp)
movaps %xmm0,%xmm6
movups -0x30(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm6
movups -0x20(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm13
movups -0x10(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm14
movups (%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x10(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0x10(%rsp),%xmm5
add    $0x1,%rsi
add    $0x140,%rdx
cmp    %rsi,%rcx
jne    1430 <smath+0x300>
movaps %xmm8,0xa0(%rsp)
movaps %xmm7,0xb0(%rsp)
movaps %xmm10,0xc0(%rsp)
movaps %xmm12,0xd0(%rsp)
movaps %xmm11,0xe0(%rsp)
movaps %xmm9,0xf0(%rsp)
movaps 0x40(%rsp),%xmm0
movaps %xmm0,0x100(%rsp)
movaps %xmm15,0x110(%rsp)
movaps 0x60(%rsp),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0x50(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
movaps %xmm3,0x140(%rsp)
movaps %xmm2,0x150(%rsp)
movaps %xmm1,0x160(%rsp)
movaps 0x70(%rsp),%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0x30(%rsp),%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0x20(%rsp),%xmm4
movaps %xmm4,0x190(%rsp)
movaps %xmm6,0x1a0(%rsp)
movaps %xmm13,0x1b0(%rsp)
movaps %xmm14,0x1c0(%rsp)
movaps %xmm5,0x1d0(%rsp)
cmp    %r15d,%r13d
jle    197d <smath+0x84d>
movslq %r13d,%rcx
movaps 0xa0(%rsp),%xmm8
movaps 0xb0(%rsp),%xmm7
movaps 0xc0(%rsp),%xmm10
movaps 0xd0(%rsp),%xmm12
movaps 0xe0(%rsp),%xmm11
movaps 0xf0(%rsp),%xmm9
movaps 0x100(%rsp),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0x110(%rsp),%xmm15
movaps 0x120(%rsp),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0x130(%rsp),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x140(%rsp),%xmm3
movaps 0x150(%rsp),%xmm2
movaps 0x160(%rsp),%xmm1
movaps 0x170(%rsp),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x180(%rsp),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0x190(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
lea    (%rax,%rax,4),%rdx
shl    $0x6,%rdx
add    %r14,%rdx
add    $0x270,%rdx
movaps 0x1a0(%rsp),%xmm6
movaps 0x1b0(%rsp),%xmm13
movaps 0x1c0(%rsp),%xmm14
movaps 0x1d0(%rsp),%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm5,0x10(%rsp)
movss  0x84(%rsp,%rax,4),%xmm4
shufps $0x0,%xmm4,%xmm4
movups -0x130(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm8
movups -0x120(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm7
movups -0x110(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm10
movups -0x100(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm12
movups -0xf0(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm11
movups -0xe0(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm9
movups -0xd0(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x40(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x40(%rsp)
movups -0xc0(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm15
movups -0xb0(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x60(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x60(%rsp)
movups -0xa0(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x50(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x50(%rsp)
movups -0x90(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm3
movups -0x80(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm2
movups -0x70(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm1
movups -0x60(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x70(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x70(%rsp)
movups -0x50(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x30(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x30(%rsp)
movups -0x40(%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps %xmm6,%xmm0
movaps 0x20(%rsp),%xmm6
addps  %xmm5,%xmm6
movaps %xmm6,0x20(%rsp)
movaps %xmm0,%xmm6
movups -0x30(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm6
movups -0x20(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm13
movups -0x10(%rdx),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm14
movups (%rdx),%xmm5
mulps  %xmm4,%xmm5
movaps 0x10(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0x10(%rsp),%xmm5
add    $0x1,%rax
add    $0x140,%rdx
cmp    %rax,%rcx
jne    1750 <smath+0x620>
movaps %xmm8,0xa0(%rsp)
movaps %xmm7,0xb0(%rsp)
movaps %xmm10,0xc0(%rsp)
movaps %xmm12,0xd0(%rsp)
movaps %xmm11,0xe0(%rsp)
movaps %xmm9,0xf0(%rsp)
movaps 0x40(%rsp),%xmm0
movaps %xmm0,0x100(%rsp)
movaps %xmm15,0x110(%rsp)
movaps 0x60(%rsp),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0x50(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
movaps %xmm3,0x140(%rsp)
movaps %xmm2,0x150(%rsp)
movaps %xmm1,0x160(%rsp)
movaps 0x70(%rsp),%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0x30(%rsp),%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0x20(%rsp),%xmm4
movaps %xmm4,0x190(%rsp)
movaps %xmm6,0x1a0(%rsp)
movaps %xmm13,0x1b0(%rsp)
movaps %xmm14,0x1c0(%rsp)
movaps %xmm5,0x1d0(%rsp)
shl    $0x4,%r15d
lea    (%r15,%r15,4),%eax
movslq %eax,%r15
lea    (%r14,%r15,4),%rbx
xorps  %xmm4,%xmm4
xorps  %xmm3,%xmm3
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rax,4),%xmm0
movss  0x9c(%rsp,%rax,4),%xmm1
movaps %xmm1,%xmm2
unpcklps %xmm0,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
movss  (%rbx,%rax,4),%xmm3
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm1
addps  %xmm4,%xmm1
movss  0xa0(%rsp,%rax,4),%xmm2
movaps %xmm2,%xmm4
unpcklps %xmm3,%xmm2
mulss  %xmm3,%xmm3
addss  %xmm0,%xmm3
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm2
movaps %xmm2,%xmm4
addps  %xmm1,%xmm4
add    $0x2,%rax
cmp    $0x51,%rax
jne    19a0 <smath+0x870>
movaps %xmm3,0x20(%rsp)
movaps %xmm4,%xmm0
movaps %xmm4,0x10(%rsp)
call   1030 <fabs@plt>
movsd  0x604(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1a21 <smath+0x8f1>
movaps 0x10(%rsp),%xmm1
jmp    1a29 <smath+0x8f9>
movss  0x5db(%rip),%xmm1
movaps 0x20(%rsp),%xmm0
movss  %xmm1,0x30(%rsp)
divss  %xmm1,%xmm0
call   1050 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  %xmm1,%xmm1
mov    $0x1,%eax
nopl   (%rax)
movss  0x9c(%rsp,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,-0x4(%r12,%rax,4)
movss  -0x4(%rbx,%rax,4),%xmm3
subss  %xmm2,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm1,%xmm3
movss  0xa0(%rsp,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%r12,%rax,4)
movss  (%rbx,%rax,4),%xmm1
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm3,%xmm1
add    $0x2,%rax
cmp    $0x51,%rax
jne    1a50 <smath+0x920>
movaps 0x20(%rsp),%xmm2
movaps %xmm2,%xmm0
mulss  0xc(%rsp),%xmm0
ucomiss %xmm0,%xmm1
movaps 0x10(%rsp),%xmm3
jbe    1e48 <smath+0xd18>
movss  0x53c(%rip),%xmm1
movaps %xmm1,%xmm5
maxss  %xmm2,%xmm5
shufps $0x55,%xmm3,%xmm3
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
movss  0x30(%rsp),%xmm4
mulss  %xmm5,%xmm4
subss  %xmm0,%xmm4
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
divss  %xmm0,%xmm4
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
xorps  %xmm0,%xmm0
ucomisd 0x51b(%rip),%xmm2
jbe    1b65 <smath+0xa35>
movss  0xc(%rsp),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
mulss  0x4f0(%rip),%xmm0
addss  %xmm1,%xmm0
divss  %xmm4,%xmm0
movaps %xmm3,0x10(%rsp)
movss  %xmm5,0x20(%rsp)
call   1050 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0xc(%rsp),%xmm1
mulss  0x4c6(%rip),%xmm1
movaps 0x10(%rsp),%xmm2
mulss  %xmm0,%xmm2
divss  0x20(%rsp),%xmm2
subss  %xmm2,%xmm1
addss  0x49f(%rip),%xmm1
lea    (%r14,%r15,4),%rax
add    $0x140,%rax
cmp    %r12,%rax
jbe    1be1 <smath+0xab1>
lea    0x140(%r12),%rax
cmp    %rax,%rbx
jae    1be1 <smath+0xab1>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rax,4),%xmm2
mulss  %xmm1,%xmm2
movss  0x9c(%rsp,%rax,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,-0x4(%r12,%rax,4)
movss  (%rbx,%rax,4),%xmm2
mulss  %xmm1,%xmm2
movss  0xa0(%rsp,%rax,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,(%r12,%rax,4)
add    $0x2,%rax
cmp    $0x51,%rax
jne    1b90 <smath+0xa60>
jmp    1e48 <smath+0xd18>
shufps $0x0,%xmm1,%xmm1
shufps $0x0,%xmm0,%xmm0
movups (%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0xa0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,(%r12)
movups 0x10(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0xb0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x10(%r12)
movups 0x20(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0xc0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x20(%r12)
movups 0x30(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0xd0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x30(%r12)
movups 0x40(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0xe0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x40(%r12)
movups 0x50(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0xf0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x50(%r12)
movups 0x60(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x100(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x60(%r12)
movups 0x70(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x110(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x70(%r12)
movups 0x80(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x120(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x80(%r12)
movups 0x90(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x130(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x90(%r12)
movups 0xa0(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x140(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xa0(%r12)
movups 0xb0(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x150(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xb0(%r12)
movups 0xc0(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x160(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xc0(%r12)
movups 0xd0(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x170(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xd0(%r12)
movups 0xe0(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x180(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xe0(%r12)
movups 0xf0(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x190(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xf0(%r12)
movups 0x100(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x1a0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x100(%r12)
movups 0x110(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x1b0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x110(%r12)
movups 0x120(%rbx),%xmm2
mulps  %xmm1,%xmm2
movaps 0x1c0(%rsp),%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x120(%r12)
movups 0x130(%rbx),%xmm2
mulps  %xmm1,%xmm2
mulps  0x1d0(%rsp),%xmm0
addps  %xmm2,%xmm0
movups %xmm0,0x130(%r12)
add    $0x468,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @smath(float* nocapture writeonly %0, float* nocapture %1, i32 %2, float %3) {
%5 = alloca [240 x float]
%6 = alloca [7 x float]
%7 = bitcast [240 x float]* %5 to i8*
%8 = bitcast [7 x float]* %6 to i8*
%9 = shl i32 %2, 1
%10 = or i32 %9, 1
%11 = icmp slt i32 %10, 1
br i1 %11, label %31, label %12
12: ; preds = %4
%13 = add i32 %9, 2
%14 = sitofp i32 %13 to float
%15 = zext i32 %13 to i64
br label %16
16: ; preds = %12, %16
%17 = phi i64 [ 1, %12 ], [ %29, %16 ]
%18 = trunc i64 %17 to i32
%19 = sitofp i32 %18 to float
%20 = fmul float %19, 0x401921FB60000000
%21 = fdiv float %20, %14
%22 = fptosi float %21 to i32
%23 = tail call i64 @cos(i32 %22)
%24 = sitofp i64 %23 to float
%25 = fsub float 1.000000e+00, %24
%26 = fmul float %25, 5.000000e-01
%27 = add nsw i64 %17, -1
%28 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %27
store float %26, float* %28
%29 = add nuw nsw i64 %17, 1
%30 = icmp eq i64 %29, %15
br i1 %30, label %31, label %16
31: ; preds = %16, %4
%32 = sext i32 %2 to i64
%33 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %32
store float 0.000000e+00, float* %33
%34 = bitcast [7 x float]* %6 to <4 x float>*
%35 = load <4 x float>, <4 x float>* %34
%36 = shufflevector <4 x float> %35, <4 x float> poison, <4 x i32> zeroinitializer
%37 = bitcast float* %1 to <4 x float>*
%38 = load <4 x float>, <4 x float>* %37
%39 = fmul <4 x float> %38, %36
%40 = bitcast [240 x float]* %5 to <4 x float>*
store <4 x float> %39, <4 x float>* %40
%41 = getelementptr inbounds float, float* %1, i64 4
%42 = bitcast float* %41 to <4 x float>*
%43 = load <4 x float>, <4 x float>* %42
%44 = fmul <4 x float> %43, %36
%45 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%46 = bitcast float* %45 to <4 x float>*
store <4 x float> %44, <4 x float>* %46
%47 = getelementptr inbounds float, float* %1, i64 8
%48 = bitcast float* %47 to <4 x float>*
%49 = load <4 x float>, <4 x float>* %48
%50 = fmul <4 x float> %49, %36
%51 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %50, <4 x float>* %52
%53 = getelementptr inbounds float, float* %1, i64 12
%54 = bitcast float* %53 to <4 x float>*
%55 = load <4 x float>, <4 x float>* %54
%56 = fmul <4 x float> %55, %36
%57 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%58 = bitcast float* %57 to <4 x float>*
store <4 x float> %56, <4 x float>* %58
%59 = getelementptr inbounds float, float* %1, i64 16
%60 = bitcast float* %59 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = fmul <4 x float> %61, %36
%63 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %62, <4 x float>* %64
%65 = getelementptr inbounds float, float* %1, i64 20
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = fmul <4 x float> %67, %36
%69 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %68, <4 x float>* %70
%71 = getelementptr inbounds float, float* %1, i64 24
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = fmul <4 x float> %73, %36
%75 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%76 = bitcast float* %75 to <4 x float>*
store <4 x float> %74, <4 x float>* %76
%77 = getelementptr inbounds float, float* %1, i64 28
%78 = bitcast float* %77 to <4 x float>*
%79 = load <4 x float>, <4 x float>* %78
%80 = fmul <4 x float> %79, %36
%81 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %80, <4 x float>* %82
%83 = getelementptr inbounds float, float* %1, i64 32
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = fmul <4 x float> %85, %36
%87 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%88 = bitcast float* %87 to <4 x float>*
store <4 x float> %86, <4 x float>* %88
%89 = getelementptr inbounds float, float* %1, i64 36
%90 = bitcast float* %89 to <4 x float>*
%91 = load <4 x float>, <4 x float>* %90
%92 = fmul <4 x float> %91, %36
%93 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%94 = bitcast float* %93 to <4 x float>*
store <4 x float> %92, <4 x float>* %94
%95 = getelementptr inbounds float, float* %1, i64 40
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = fmul <4 x float> %97, %36
%99 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%100 = bitcast float* %99 to <4 x float>*
store <4 x float> %98, <4 x float>* %100
%101 = getelementptr inbounds float, float* %1, i64 44
%102 = bitcast float* %101 to <4 x float>*
%103 = load <4 x float>, <4 x float>* %102
%104 = fmul <4 x float> %103, %36
%105 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %104, <4 x float>* %106
%107 = getelementptr inbounds float, float* %1, i64 48
%108 = bitcast float* %107 to <4 x float>*
%109 = load <4 x float>, <4 x float>* %108
%110 = fmul <4 x float> %109, %36
%111 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%112 = bitcast float* %111 to <4 x float>*
store <4 x float> %110, <4 x float>* %112
%113 = getelementptr inbounds float, float* %1, i64 52
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = fmul <4 x float> %115, %36
%117 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%118 = bitcast float* %117 to <4 x float>*
store <4 x float> %116, <4 x float>* %118
%119 = getelementptr inbounds float, float* %1, i64 56
%120 = bitcast float* %119 to <4 x float>*
%121 = load <4 x float>, <4 x float>* %120
%122 = fmul <4 x float> %121, %36
%123 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%124 = bitcast float* %123 to <4 x float>*
store <4 x float> %122, <4 x float>* %124
%125 = getelementptr inbounds float, float* %1, i64 60
%126 = bitcast float* %125 to <4 x float>*
%127 = load <4 x float>, <4 x float>* %126
%128 = fmul <4 x float> %127, %36
%129 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%130 = bitcast float* %129 to <4 x float>*
store <4 x float> %128, <4 x float>* %130
%131 = getelementptr inbounds float, float* %1, i64 64
%132 = bitcast float* %131 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = fmul <4 x float> %133, %36
%135 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%136 = bitcast float* %135 to <4 x float>*
store <4 x float> %134, <4 x float>* %136
%137 = getelementptr inbounds float, float* %1, i64 68
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = fmul <4 x float> %139, %36
%141 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%142 = bitcast float* %141 to <4 x float>*
store <4 x float> %140, <4 x float>* %142
%143 = getelementptr inbounds float, float* %1, i64 72
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = fmul <4 x float> %145, %36
%147 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%148 = bitcast float* %147 to <4 x float>*
store <4 x float> %146, <4 x float>* %148
%149 = getelementptr inbounds float, float* %1, i64 76
%150 = bitcast float* %149 to <4 x float>*
%151 = load <4 x float>, <4 x float>* %150
%152 = fmul <4 x float> %151, %36
%153 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %152, <4 x float>* %154
%155 = icmp sgt i32 %2, 1
br i1 %155, label %156, label %218
156: ; preds = %31
%157 = zext i32 %2 to i64
%158 = bitcast [240 x float]* %5 to <4 x float>*
%159 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%160 = bitcast float* %159 to <4 x float>*
%161 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%162 = bitcast float* %161 to <4 x float>*
%163 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%164 = bitcast float* %163 to <4 x float>*
%165 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%166 = bitcast float* %165 to <4 x float>*
%167 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%168 = bitcast float* %167 to <4 x float>*
%169 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%170 = bitcast float* %169 to <4 x float>*
%171 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%172 = bitcast float* %171 to <4 x float>*
%173 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%174 = bitcast float* %173 to <4 x float>*
%175 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%176 = bitcast float* %175 to <4 x float>*
%177 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%178 = bitcast float* %177 to <4 x float>*
%179 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%180 = bitcast float* %179 to <4 x float>*
%181 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%182 = bitcast float* %181 to <4 x float>*
%183 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%184 = bitcast float* %183 to <4 x float>*
%185 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%186 = bitcast float* %185 to <4 x float>*
%187 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%188 = bitcast float* %187 to <4 x float>*
%189 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%190 = bitcast float* %189 to <4 x float>*
%191 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%192 = bitcast float* %191 to <4 x float>*
%193 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%194 = bitcast float* %193 to <4 x float>*
%195 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%196 = bitcast float* %195 to <4 x float>*
%197 = load <4 x float>, <4 x float>* %158
%198 = load <4 x float>, <4 x float>* %160
%199 = load <4 x float>, <4 x float>* %162
%200 = load <4 x float>, <4 x float>* %164
%201 = load <4 x float>, <4 x float>* %166
%202 = load <4 x float>, <4 x float>* %168
%203 = load <4 x float>, <4 x float>* %170
%204 = load <4 x float>, <4 x float>* %172
%205 = load <4 x float>, <4 x float>* %174
%206 = load <4 x float>, <4 x float>* %176
%207 = load <4 x float>, <4 x float>* %178
%208 = load <4 x float>, <4 x float>* %180
%209 = load <4 x float>, <4 x float>* %182
%210 = load <4 x float>, <4 x float>* %184
%211 = load <4 x float>, <4 x float>* %186
%212 = load <4 x float>, <4 x float>* %188
%213 = load <4 x float>, <4 x float>* %190
%214 = load <4 x float>, <4 x float>* %192
%215 = load <4 x float>, <4 x float>* %194
%216 = load <4 x float>, <4 x float>* %196
br label %281
217: ; preds = %281
store <4 x float> %311, <4 x float>* %158
store <4 x float> %315, <4 x float>* %160
store <4 x float> %319, <4 x float>* %162
store <4 x float> %323, <4 x float>* %164
store <4 x float> %327, <4 x float>* %166
store <4 x float> %331, <4 x float>* %168
store <4 x float> %335, <4 x float>* %170
store <4 x float> %339, <4 x float>* %172
store <4 x float> %343, <4 x float>* %174
store <4 x float> %347, <4 x float>* %176
store <4 x float> %351, <4 x float>* %178
store <4 x float> %355, <4 x float>* %180
store <4 x float> %359, <4 x float>* %182
store <4 x float> %363, <4 x float>* %184
store <4 x float> %367, <4 x float>* %186
store <4 x float> %371, <4 x float>* %188
store <4 x float> %375, <4 x float>* %190
store <4 x float> %379, <4 x float>* %192
store <4 x float> %383, <4 x float>* %194
store <4 x float> %387, <4 x float>* %196
br label %218
218: ; preds = %217, %31
%219 = icmp sgt i32 %9, %2
br i1 %219, label %220, label %500
220: ; preds = %218
%221 = sext i32 %9 to i64
%222 = bitcast [240 x float]* %5 to <4 x float>*
%223 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%224 = bitcast float* %223 to <4 x float>*
%225 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%226 = bitcast float* %225 to <4 x float>*
%227 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%228 = bitcast float* %227 to <4 x float>*
%229 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%230 = bitcast float* %229 to <4 x float>*
%231 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%232 = bitcast float* %231 to <4 x float>*
%233 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%234 = bitcast float* %233 to <4 x float>*
%235 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%236 = bitcast float* %235 to <4 x float>*
%237 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%238 = bitcast float* %237 to <4 x float>*
%239 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%240 = bitcast float* %239 to <4 x float>*
%241 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%242 = bitcast float* %241 to <4 x float>*
%243 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%244 = bitcast float* %243 to <4 x float>*
%245 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%246 = bitcast float* %245 to <4 x float>*
%247 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%248 = bitcast float* %247 to <4 x float>*
%249 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%250 = bitcast float* %249 to <4 x float>*
%251 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%252 = bitcast float* %251 to <4 x float>*
%253 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%254 = bitcast float* %253 to <4 x float>*
%255 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%256 = bitcast float* %255 to <4 x float>*
%257 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%258 = bitcast float* %257 to <4 x float>*
%259 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%260 = bitcast float* %259 to <4 x float>*
%261 = load <4 x float>, <4 x float>* %222
%262 = load <4 x float>, <4 x float>* %224
%263 = load <4 x float>, <4 x float>* %226
%264 = load <4 x float>, <4 x float>* %228
%265 = load <4 x float>, <4 x float>* %230
%266 = load <4 x float>, <4 x float>* %232
%267 = load <4 x float>, <4 x float>* %234
%268 = load <4 x float>, <4 x float>* %236
%269 = load <4 x float>, <4 x float>* %238
%270 = load <4 x float>, <4 x float>* %240
%271 = load <4 x float>, <4 x float>* %242
%272 = load <4 x float>, <4 x float>* %244
%273 = load <4 x float>, <4 x float>* %246
%274 = load <4 x float>, <4 x float>* %248
%275 = load <4 x float>, <4 x float>* %250
%276 = load <4 x float>, <4 x float>* %252
%277 = load <4 x float>, <4 x float>* %254
%278 = load <4 x float>, <4 x float>* %256
%279 = load <4 x float>, <4 x float>* %258
%280 = load <4 x float>, <4 x float>* %260
br label %390
281: ; preds = %156, %281
%282 = phi <4 x float> [ %216, %156 ], [ %387, %281 ]
%283 = phi <4 x float> [ %215, %156 ], [ %383, %281 ]
%284 = phi <4 x float> [ %214, %156 ], [ %379, %281 ]
%285 = phi <4 x float> [ %213, %156 ], [ %375, %281 ]
%286 = phi <4 x float> [ %212, %156 ], [ %371, %281 ]
%287 = phi <4 x float> [ %211, %156 ], [ %367, %281 ]
%288 = phi <4 x float> [ %210, %156 ], [ %363, %281 ]
%289 = phi <4 x float> [ %209, %156 ], [ %359, %281 ]
%290 = phi <4 x float> [ %208, %156 ], [ %355, %281 ]
%291 = phi <4 x float> [ %207, %156 ], [ %351, %281 ]
%292 = phi <4 x float> [ %206, %156 ], [ %347, %281 ]
%293 = phi <4 x float> [ %205, %156 ], [ %343, %281 ]
%294 = phi <4 x float> [ %204, %156 ], [ %339, %281 ]
%295 = phi <4 x float> [ %203, %156 ], [ %335, %281 ]
%296 = phi <4 x float> [ %202, %156 ], [ %331, %281 ]
%297 = phi <4 x float> [ %201, %156 ], [ %327, %281 ]
%298 = phi <4 x float> [ %200, %156 ], [ %323, %281 ]
%299 = phi <4 x float> [ %199, %156 ], [ %319, %281 ]
%300 = phi <4 x float> [ %198, %156 ], [ %315, %281 ]
%301 = phi <4 x float> [ %197, %156 ], [ %311, %281 ]
%302 = phi i64 [ 1, %156 ], [ %388, %281 ]
%303 = mul nuw nsw i64 %302, 80
%304 = getelementptr inbounds float, float* %1, i64 %303
%305 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %302
%306 = load float, float* %305
%307 = insertelement <4 x float> poison, float %306, i64 0
%308 = shufflevector <4 x float> %307, <4 x float> poison, <4 x i32> zeroinitializer
%309 = bitcast float* %304 to <4 x float>*
%310 = load <4 x float>, <4 x float>* %309
%311 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %310, <4 x float> %308, <4 x float> %301)
%312 = getelementptr inbounds float, float* %304, i64 4
%313 = bitcast float* %312 to <4 x float>*
%314 = load <4 x float>, <4 x float>* %313
%315 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %314, <4 x float> %308, <4 x float> %300)
%316 = getelementptr inbounds float, float* %304, i64 8
%317 = bitcast float* %316 to <4 x float>*
%318 = load <4 x float>, <4 x float>* %317
%319 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %318, <4 x float> %308, <4 x float> %299)
%320 = getelementptr inbounds float, float* %304, i64 12
%321 = bitcast float* %320 to <4 x float>*
%322 = load <4 x float>, <4 x float>* %321
%323 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %322, <4 x float> %308, <4 x float> %298)
%324 = getelementptr inbounds float, float* %304, i64 16
%325 = bitcast float* %324 to <4 x float>*
%326 = load <4 x float>, <4 x float>* %325
%327 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %326, <4 x float> %308, <4 x float> %297)
%328 = getelementptr inbounds float, float* %304, i64 20
%329 = bitcast float* %328 to <4 x float>*
%330 = load <4 x float>, <4 x float>* %329
%331 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %330, <4 x float> %308, <4 x float> %296)
%332 = getelementptr inbounds float, float* %304, i64 24
%333 = bitcast float* %332 to <4 x float>*
%334 = load <4 x float>, <4 x float>* %333
%335 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %334, <4 x float> %308, <4 x float> %295)
%336 = getelementptr inbounds float, float* %304, i64 28
%337 = bitcast float* %336 to <4 x float>*
%338 = load <4 x float>, <4 x float>* %337
%339 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %338, <4 x float> %308, <4 x float> %294)
%340 = getelementptr inbounds float, float* %304, i64 32
%341 = bitcast float* %340 to <4 x float>*
%342 = load <4 x float>, <4 x float>* %341
%343 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %342, <4 x float> %308, <4 x float> %293)
%344 = getelementptr inbounds float, float* %304, i64 36
%345 = bitcast float* %344 to <4 x float>*
%346 = load <4 x float>, <4 x float>* %345
%347 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %346, <4 x float> %308, <4 x float> %292)
%348 = getelementptr inbounds float, float* %304, i64 40
%349 = bitcast float* %348 to <4 x float>*
%350 = load <4 x float>, <4 x float>* %349
%351 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %350, <4 x float> %308, <4 x float> %291)
%352 = getelementptr inbounds float, float* %304, i64 44
%353 = bitcast float* %352 to <4 x float>*
%354 = load <4 x float>, <4 x float>* %353
%355 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %354, <4 x float> %308, <4 x float> %290)
%356 = getelementptr inbounds float, float* %304, i64 48
%357 = bitcast float* %356 to <4 x float>*
%358 = load <4 x float>, <4 x float>* %357
%359 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %358, <4 x float> %308, <4 x float> %289)
%360 = getelementptr inbounds float, float* %304, i64 52
%361 = bitcast float* %360 to <4 x float>*
%362 = load <4 x float>, <4 x float>* %361
%363 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %362, <4 x float> %308, <4 x float> %288)
%364 = getelementptr inbounds float, float* %304, i64 56
%365 = bitcast float* %364 to <4 x float>*
%366 = load <4 x float>, <4 x float>* %365
%367 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %366, <4 x float> %308, <4 x float> %287)
%368 = getelementptr inbounds float, float* %304, i64 60
%369 = bitcast float* %368 to <4 x float>*
%370 = load <4 x float>, <4 x float>* %369
%371 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %370, <4 x float> %308, <4 x float> %286)
%372 = getelementptr inbounds float, float* %304, i64 64
%373 = bitcast float* %372 to <4 x float>*
%374 = load <4 x float>, <4 x float>* %373
%375 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %374, <4 x float> %308, <4 x float> %285)
%376 = getelementptr inbounds float, float* %304, i64 68
%377 = bitcast float* %376 to <4 x float>*
%378 = load <4 x float>, <4 x float>* %377
%379 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %378, <4 x float> %308, <4 x float> %284)
%380 = getelementptr inbounds float, float* %304, i64 72
%381 = bitcast float* %380 to <4 x float>*
%382 = load <4 x float>, <4 x float>* %381
%383 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %382, <4 x float> %308, <4 x float> %283)
%384 = getelementptr inbounds float, float* %304, i64 76
%385 = bitcast float* %384 to <4 x float>*
%386 = load <4 x float>, <4 x float>* %385
%387 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %386, <4 x float> %308, <4 x float> %282)
%388 = add nuw nsw i64 %302, 1
%389 = icmp eq i64 %388, %157
br i1 %389, label %217, label %281
390: ; preds = %220, %390
%391 = phi <4 x float> [ %280, %220 ], [ %497, %390 ]
%392 = phi <4 x float> [ %279, %220 ], [ %493, %390 ]
%393 = phi <4 x float> [ %278, %220 ], [ %489, %390 ]
%394 = phi <4 x float> [ %277, %220 ], [ %485, %390 ]
%395 = phi <4 x float> [ %276, %220 ], [ %481, %390 ]
%396 = phi <4 x float> [ %275, %220 ], [ %477, %390 ]
%397 = phi <4 x float> [ %274, %220 ], [ %473, %390 ]
%398 = phi <4 x float> [ %273, %220 ], [ %469, %390 ]
%399 = phi <4 x float> [ %272, %220 ], [ %465, %390 ]
%400 = phi <4 x float> [ %271, %220 ], [ %461, %390 ]
%401 = phi <4 x float> [ %270, %220 ], [ %457, %390 ]
%402 = phi <4 x float> [ %269, %220 ], [ %453, %390 ]
%403 = phi <4 x float> [ %268, %220 ], [ %449, %390 ]
%404 = phi <4 x float> [ %267, %220 ], [ %445, %390 ]
%405 = phi <4 x float> [ %266, %220 ], [ %441, %390 ]
%406 = phi <4 x float> [ %265, %220 ], [ %437, %390 ]
%407 = phi <4 x float> [ %264, %220 ], [ %433, %390 ]
%408 = phi <4 x float> [ %263, %220 ], [ %429, %390 ]
%409 = phi <4 x float> [ %262, %220 ], [ %425, %390 ]
%410 = phi <4 x float> [ %261, %220 ], [ %421, %390 ]
%411 = phi i64 [ %32, %220 ], [ %412, %390 ]
%412 = add nsw i64 %411, 1
%413 = mul nsw i64 %412, 80
%414 = getelementptr inbounds float, float* %1, i64 %413
%415 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %412
%416 = load float, float* %415
%417 = insertelement <4 x float> poison, float %416, i64 0
%418 = shufflevector <4 x float> %417, <4 x float> poison, <4 x i32> zeroinitializer
%419 = bitcast float* %414 to <4 x float>*
%420 = load <4 x float>, <4 x float>* %419
%421 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %420, <4 x float> %418, <4 x float> %410)
%422 = getelementptr inbounds float, float* %414, i64 4
%423 = bitcast float* %422 to <4 x float>*
%424 = load <4 x float>, <4 x float>* %423
%425 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %424, <4 x float> %418, <4 x float> %409)
%426 = getelementptr inbounds float, float* %414, i64 8
%427 = bitcast float* %426 to <4 x float>*
%428 = load <4 x float>, <4 x float>* %427
%429 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %428, <4 x float> %418, <4 x float> %408)
%430 = getelementptr inbounds float, float* %414, i64 12
%431 = bitcast float* %430 to <4 x float>*
%432 = load <4 x float>, <4 x float>* %431
%433 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %432, <4 x float> %418, <4 x float> %407)
%434 = getelementptr inbounds float, float* %414, i64 16
%435 = bitcast float* %434 to <4 x float>*
%436 = load <4 x float>, <4 x float>* %435
%437 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %436, <4 x float> %418, <4 x float> %406)
%438 = getelementptr inbounds float, float* %414, i64 20
%439 = bitcast float* %438 to <4 x float>*
%440 = load <4 x float>, <4 x float>* %439
%441 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %440, <4 x float> %418, <4 x float> %405)
%442 = getelementptr inbounds float, float* %414, i64 24
%443 = bitcast float* %442 to <4 x float>*
%444 = load <4 x float>, <4 x float>* %443
%445 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %444, <4 x float> %418, <4 x float> %404)
%446 = getelementptr inbounds float, float* %414, i64 28
%447 = bitcast float* %446 to <4 x float>*
%448 = load <4 x float>, <4 x float>* %447
%449 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %448, <4 x float> %418, <4 x float> %403)
%450 = getelementptr inbounds float, float* %414, i64 32
%451 = bitcast float* %450 to <4 x float>*
%452 = load <4 x float>, <4 x float>* %451
%453 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %452, <4 x float> %418, <4 x float> %402)
%454 = getelementptr inbounds float, float* %414, i64 36
%455 = bitcast float* %454 to <4 x float>*
%456 = load <4 x float>, <4 x float>* %455
%457 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %456, <4 x float> %418, <4 x float> %401)
%458 = getelementptr inbounds float, float* %414, i64 40
%459 = bitcast float* %458 to <4 x float>*
%460 = load <4 x float>, <4 x float>* %459
%461 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %460, <4 x float> %418, <4 x float> %400)
%462 = getelementptr inbounds float, float* %414, i64 44
%463 = bitcast float* %462 to <4 x float>*
%464 = load <4 x float>, <4 x float>* %463
%465 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %464, <4 x float> %418, <4 x float> %399)
%466 = getelementptr inbounds float, float* %414, i64 48
%467 = bitcast float* %466 to <4 x float>*
%468 = load <4 x float>, <4 x float>* %467
%469 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %468, <4 x float> %418, <4 x float> %398)
%470 = getelementptr inbounds float, float* %414, i64 52
%471 = bitcast float* %470 to <4 x float>*
%472 = load <4 x float>, <4 x float>* %471
%473 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %472, <4 x float> %418, <4 x float> %397)
%474 = getelementptr inbounds float, float* %414, i64 56
%475 = bitcast float* %474 to <4 x float>*
%476 = load <4 x float>, <4 x float>* %475
%477 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %476, <4 x float> %418, <4 x float> %396)
%478 = getelementptr inbounds float, float* %414, i64 60
%479 = bitcast float* %478 to <4 x float>*
%480 = load <4 x float>, <4 x float>* %479
%481 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %480, <4 x float> %418, <4 x float> %395)
%482 = getelementptr inbounds float, float* %414, i64 64
%483 = bitcast float* %482 to <4 x float>*
%484 = load <4 x float>, <4 x float>* %483
%485 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %484, <4 x float> %418, <4 x float> %394)
%486 = getelementptr inbounds float, float* %414, i64 68
%487 = bitcast float* %486 to <4 x float>*
%488 = load <4 x float>, <4 x float>* %487
%489 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %488, <4 x float> %418, <4 x float> %393)
%490 = getelementptr inbounds float, float* %414, i64 72
%491 = bitcast float* %490 to <4 x float>*
%492 = load <4 x float>, <4 x float>* %491
%493 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %492, <4 x float> %418, <4 x float> %392)
%494 = getelementptr inbounds float, float* %414, i64 76
%495 = bitcast float* %494 to <4 x float>*
%496 = load <4 x float>, <4 x float>* %495
%497 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %496, <4 x float> %418, <4 x float> %391)
%498 = icmp eq i64 %412, %221
br i1 %498, label %499, label %390
499: ; preds = %390
store <4 x float> %421, <4 x float>* %222
store <4 x float> %425, <4 x float>* %224
store <4 x float> %429, <4 x float>* %226
store <4 x float> %433, <4 x float>* %228
store <4 x float> %437, <4 x float>* %230
store <4 x float> %441, <4 x float>* %232
store <4 x float> %445, <4 x float>* %234
store <4 x float> %449, <4 x float>* %236
store <4 x float> %453, <4 x float>* %238
store <4 x float> %457, <4 x float>* %240
store <4 x float> %461, <4 x float>* %242
store <4 x float> %465, <4 x float>* %244
store <4 x float> %469, <4 x float>* %246
store <4 x float> %473, <4 x float>* %248
store <4 x float> %477, <4 x float>* %250
store <4 x float> %481, <4 x float>* %252
store <4 x float> %485, <4 x float>* %254
store <4 x float> %489, <4 x float>* %256
store <4 x float> %493, <4 x float>* %258
store <4 x float> %497, <4 x float>* %260
br label %500
500: ; preds = %499, %218
%501 = mul nsw i32 %2, 80
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds float, float* %1, i64 %502
br label %504
504: ; preds = %504, %500
%505 = phi i64 [ 0, %500 ], [ %527, %504 ]
%506 = phi float [ 0.000000e+00, %500 ], [ %520, %504 ]
%507 = phi <2 x float> [ zeroinitializer, %500 ], [ %526, %504 ]
%508 = getelementptr inbounds float, float* %503, i64 %505
%509 = load float, float* %508
%510 = tail call float @llvm.fmuladd.f32(float %509, float %509, float %506)
%511 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %505
%512 = load float, float* %511
%513 = insertelement <2 x float> poison, float %512, i64 0
%514 = shufflevector <2 x float> %513, <2 x float> poison, <2 x i32> zeroinitializer
%515 = insertelement <2 x float> %513, float %509, i64 1
%516 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %514, <2 x float> %515, <2 x float> %507)
%517 = or i64 %505, 1
%518 = getelementptr inbounds float, float* %503, i64 %517
%519 = load float, float* %518
%520 = tail call float @llvm.fmuladd.f32(float %519, float %519, float %510)
%521 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %517
%522 = load float, float* %521
%523 = insertelement <2 x float> poison, float %522, i64 0
%524 = shufflevector <2 x float> %523, <2 x float> poison, <2 x i32> zeroinitializer
%525 = insertelement <2 x float> %523, float %519, i64 1
%526 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %524, <2 x float> %525, <2 x float> %516)
%527 = add nuw nsw i64 %505, 2
%528 = icmp eq i64 %527, 80
br i1 %528, label %529, label %504
529: ; preds = %504
%530 = extractelement <2 x float> %526, i64 0
%531 = tail call double @fabs(float %530)
%532 = fcmp olt double %531, 1.000000e+00
%533 = select i1 %532, float 1.000000e+00, float %530
%534 = fdiv float %520, %533
%535 = tail call i64 @sqrt(float %534)
%536 = sitofp i64 %535 to float
br label %537
537: ; preds = %537, %529
%538 = phi i64 [ 0, %529 ], [ %557, %537 ]
%539 = phi float [ 0.000000e+00, %529 ], [ %556, %537 ]
%540 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %538
%541 = load float, float* %540
%542 = fmul float %541, %536
%543 = getelementptr inbounds float, float* %0, i64 %538
store float %542, float* %543
%544 = getelementptr inbounds float, float* %503, i64 %538
%545 = load float, float* %544
%546 = fsub float %545, %542
%547 = tail call float @llvm.fmuladd.f32(float %546, float %546, float %539)
%548 = or i64 %538, 1
%549 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %548
%550 = load float, float* %549
%551 = fmul float %550, %536
%552 = getelementptr inbounds float, float* %0, i64 %548
store float %551, float* %552
%553 = getelementptr inbounds float, float* %503, i64 %548
%554 = load float, float* %553
%555 = fsub float %554, %551
%556 = tail call float @llvm.fmuladd.f32(float %555, float %555, float %547)
%557 = add nuw nsw i64 %538, 2
%558 = icmp eq i64 %557, 80
br i1 %558, label %559, label %537
559: ; preds = %537
%560 = fmul float %520, %3
%561 = fcmp ogt float %556, %560
br i1 %561, label %562, label %815
562: ; preds = %559
%563 = fcmp olt float %520, 1.000000e+00
%564 = select i1 %563, float 1.000000e+00, float %520
%565 = extractelement <2 x float> %526, i64 1
%566 = fneg float %565
%567 = fmul float %565, %566
%568 = tail call float @llvm.fmuladd.f32(float %533, float %564, float %567)
%569 = fmul float %564, %564
%570 = fdiv float %568, %569
%571 = fpext float %570 to double
%572 = fcmp ogt double %571, 1.000000e-04
br i1 %572, label %573, label %585
573: ; preds = %562
%574 = fmul float %3, %3
%575 = fmul float %574, 2.500000e-01
%576 = fsub float %3, %575
%577 = fdiv float %576, %570
%578 = tail call i64 @sqrt(float %577)
%579 = sitofp i64 %578 to float
%580 = fmul float %3, -5.000000e-01
%581 = fmul float %565, %579
%582 = fdiv float %581, %564
%583 = fsub float %580, %582
%584 = fadd float %583, 1.000000e+00
br label %585
585: ; preds = %573, %562
%586 = phi float [ %579, %573 ], [ 0.000000e+00, %562 ]
%587 = phi float [ %584, %573 ], [ 1.000000e+00, %562 ]
%588 = getelementptr float, float* %0, i64 80
%589 = add nsw i64 %502, 80
%590 = getelementptr float, float* %1, i64 %589
%591 = icmp ugt float* %590, %0
%592 = icmp ult float* %503, %588
%593 = and i1 %591, %592
br i1 %593, label %796, label %594
594: ; preds = %585
%595 = insertelement <4 x float> poison, float %587, i64 0
%596 = shufflevector <4 x float> %595, <4 x float> poison, <4 x i32> zeroinitializer
%597 = insertelement <4 x float> poison, float %586, i64 0
%598 = shufflevector <4 x float> %597, <4 x float> poison, <4 x i32> zeroinitializer
%599 = bitcast [240 x float]* %5 to <4 x float>*
%600 = load <4 x float>, <4 x float>* %599
%601 = bitcast float* %503 to <4 x float>*
%602 = load <4 x float>, <4 x float>* %601
%603 = fmul <4 x float> %596, %602
%604 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %600, <4 x float> %603)
%605 = bitcast float* %0 to <4 x float>*
store <4 x float> %604, <4 x float>* %605
%606 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%607 = bitcast float* %606 to <4 x float>*
%608 = load <4 x float>, <4 x float>* %607
%609 = getelementptr inbounds float, float* %503, i64 4
%610 = bitcast float* %609 to <4 x float>*
%611 = load <4 x float>, <4 x float>* %610
%612 = fmul <4 x float> %596, %611
%613 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %608, <4 x float> %612)
%614 = getelementptr inbounds float, float* %0, i64 4
%615 = bitcast float* %614 to <4 x float>*
store <4 x float> %613, <4 x float>* %615
%616 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%617 = bitcast float* %616 to <4 x float>*
%618 = load <4 x float>, <4 x float>* %617
%619 = getelementptr inbounds float, float* %503, i64 8
%620 = bitcast float* %619 to <4 x float>*
%621 = load <4 x float>, <4 x float>* %620
%622 = fmul <4 x float> %596, %621
%623 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %618, <4 x float> %622)
%624 = getelementptr inbounds float, float* %0, i64 8
%625 = bitcast float* %624 to <4 x float>*
store <4 x float> %623, <4 x float>* %625
%626 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%627 = bitcast float* %626 to <4 x float>*
%628 = load <4 x float>, <4 x float>* %627
%629 = getelementptr inbounds float, float* %503, i64 12
%630 = bitcast float* %629 to <4 x float>*
%631 = load <4 x float>, <4 x float>* %630
%632 = fmul <4 x float> %596, %631
%633 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %628, <4 x float> %632)
%634 = getelementptr inbounds float, float* %0, i64 12
%635 = bitcast float* %634 to <4 x float>*
store <4 x float> %633, <4 x float>* %635
%636 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%637 = bitcast float* %636 to <4 x float>*
%638 = load <4 x float>, <4 x float>* %637
%639 = getelementptr inbounds float, float* %503, i64 16
%640 = bitcast float* %639 to <4 x float>*
%641 = load <4 x float>, <4 x float>* %640
%642 = fmul <4 x float> %596, %641
%643 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %638, <4 x float> %642)
%644 = getelementptr inbounds float, float* %0, i64 16
%645 = bitcast float* %644 to <4 x float>*
store <4 x float> %643, <4 x float>* %645
%646 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%647 = bitcast float* %646 to <4 x float>*
%648 = load <4 x float>, <4 x float>* %647
%649 = getelementptr inbounds float, float* %503, i64 20
%650 = bitcast float* %649 to <4 x float>*
%651 = load <4 x float>, <4 x float>* %650
%652 = fmul <4 x float> %596, %651
%653 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %648, <4 x float> %652)
%654 = getelementptr inbounds float, float* %0, i64 20
%655 = bitcast float* %654 to <4 x float>*
store <4 x float> %653, <4 x float>* %655
%656 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%657 = bitcast float* %656 to <4 x float>*
%658 = load <4 x float>, <4 x float>* %657
%659 = getelementptr inbounds float, float* %503, i64 24
%660 = bitcast float* %659 to <4 x float>*
%661 = load <4 x float>, <4 x float>* %660
%662 = fmul <4 x float> %596, %661
%663 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %658, <4 x float> %662)
%664 = getelementptr inbounds float, float* %0, i64 24
%665 = bitcast float* %664 to <4 x float>*
store <4 x float> %663, <4 x float>* %665
%666 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%667 = bitcast float* %666 to <4 x float>*
%668 = load <4 x float>, <4 x float>* %667
%669 = getelementptr inbounds float, float* %503, i64 28
%670 = bitcast float* %669 to <4 x float>*
%671 = load <4 x float>, <4 x float>* %670
%672 = fmul <4 x float> %596, %671
%673 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %668, <4 x float> %672)
%674 = getelementptr inbounds float, float* %0, i64 28
%675 = bitcast float* %674 to <4 x float>*
store <4 x float> %673, <4 x float>* %675
%676 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%677 = bitcast float* %676 to <4 x float>*
%678 = load <4 x float>, <4 x float>* %677
%679 = getelementptr inbounds float, float* %503, i64 32
%680 = bitcast float* %679 to <4 x float>*
%681 = load <4 x float>, <4 x float>* %680
%682 = fmul <4 x float> %596, %681
%683 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %678, <4 x float> %682)
%684 = getelementptr inbounds float, float* %0, i64 32
%685 = bitcast float* %684 to <4 x float>*
store <4 x float> %683, <4 x float>* %685
%686 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%687 = bitcast float* %686 to <4 x float>*
%688 = load <4 x float>, <4 x float>* %687
%689 = getelementptr inbounds float, float* %503, i64 36
%690 = bitcast float* %689 to <4 x float>*
%691 = load <4 x float>, <4 x float>* %690
%692 = fmul <4 x float> %596, %691
%693 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %688, <4 x float> %692)
%694 = getelementptr inbounds float, float* %0, i64 36
%695 = bitcast float* %694 to <4 x float>*
store <4 x float> %693, <4 x float>* %695
%696 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%697 = bitcast float* %696 to <4 x float>*
%698 = load <4 x float>, <4 x float>* %697
%699 = getelementptr inbounds float, float* %503, i64 40
%700 = bitcast float* %699 to <4 x float>*
%701 = load <4 x float>, <4 x float>* %700
%702 = fmul <4 x float> %596, %701
%703 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %698, <4 x float> %702)
%704 = getelementptr inbounds float, float* %0, i64 40
%705 = bitcast float* %704 to <4 x float>*
store <4 x float> %703, <4 x float>* %705
%706 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%707 = bitcast float* %706 to <4 x float>*
%708 = load <4 x float>, <4 x float>* %707
%709 = getelementptr inbounds float, float* %503, i64 44
%710 = bitcast float* %709 to <4 x float>*
%711 = load <4 x float>, <4 x float>* %710
%712 = fmul <4 x float> %596, %711
%713 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %708, <4 x float> %712)
%714 = getelementptr inbounds float, float* %0, i64 44
%715 = bitcast float* %714 to <4 x float>*
store <4 x float> %713, <4 x float>* %715
%716 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%717 = bitcast float* %716 to <4 x float>*
%718 = load <4 x float>, <4 x float>* %717
%719 = getelementptr inbounds float, float* %503, i64 48
%720 = bitcast float* %719 to <4 x float>*
%721 = load <4 x float>, <4 x float>* %720
%722 = fmul <4 x float> %596, %721
%723 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %718, <4 x float> %722)
%724 = getelementptr inbounds float, float* %0, i64 48
%725 = bitcast float* %724 to <4 x float>*
store <4 x float> %723, <4 x float>* %725
%726 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%727 = bitcast float* %726 to <4 x float>*
%728 = load <4 x float>, <4 x float>* %727
%729 = getelementptr inbounds float, float* %503, i64 52
%730 = bitcast float* %729 to <4 x float>*
%731 = load <4 x float>, <4 x float>* %730
%732 = fmul <4 x float> %596, %731
%733 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %728, <4 x float> %732)
%734 = getelementptr inbounds float, float* %0, i64 52
%735 = bitcast float* %734 to <4 x float>*
store <4 x float> %733, <4 x float>* %735
%736 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%737 = bitcast float* %736 to <4 x float>*
%738 = load <4 x float>, <4 x float>* %737
%739 = getelementptr inbounds float, float* %503, i64 56
%740 = bitcast float* %739 to <4 x float>*
%741 = load <4 x float>, <4 x float>* %740
%742 = fmul <4 x float> %596, %741
%743 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %738, <4 x float> %742)
%744 = getelementptr inbounds float, float* %0, i64 56
%745 = bitcast float* %744 to <4 x float>*
store <4 x float> %743, <4 x float>* %745
%746 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%747 = bitcast float* %746 to <4 x float>*
%748 = load <4 x float>, <4 x float>* %747
%749 = getelementptr inbounds float, float* %503, i64 60
%750 = bitcast float* %749 to <4 x float>*
%751 = load <4 x float>, <4 x float>* %750
%752 = fmul <4 x float> %596, %751
%753 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %748, <4 x float> %752)
%754 = getelementptr inbounds float, float* %0, i64 60
%755 = bitcast float* %754 to <4 x float>*
store <4 x float> %753, <4 x float>* %755
%756 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%757 = bitcast float* %756 to <4 x float>*
%758 = load <4 x float>, <4 x float>* %757
%759 = getelementptr inbounds float, float* %503, i64 64
%760 = bitcast float* %759 to <4 x float>*
%761 = load <4 x float>, <4 x float>* %760
%762 = fmul <4 x float> %596, %761
%763 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %758, <4 x float> %762)
%764 = getelementptr inbounds float, float* %0, i64 64
%765 = bitcast float* %764 to <4 x float>*
store <4 x float> %763, <4 x float>* %765
%766 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%767 = bitcast float* %766 to <4 x float>*
%768 = load <4 x float>, <4 x float>* %767
%769 = getelementptr inbounds float, float* %503, i64 68
%770 = bitcast float* %769 to <4 x float>*
%771 = load <4 x float>, <4 x float>* %770
%772 = fmul <4 x float> %596, %771
%773 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %768, <4 x float> %772)
%774 = getelementptr inbounds float, float* %0, i64 68
%775 = bitcast float* %774 to <4 x float>*
store <4 x float> %773, <4 x float>* %775
%776 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%777 = bitcast float* %776 to <4 x float>*
%778 = load <4 x float>, <4 x float>* %777
%779 = getelementptr inbounds float, float* %503, i64 72
%780 = bitcast float* %779 to <4 x float>*
%781 = load <4 x float>, <4 x float>* %780
%782 = fmul <4 x float> %596, %781
%783 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %778, <4 x float> %782)
%784 = getelementptr inbounds float, float* %0, i64 72
%785 = bitcast float* %784 to <4 x float>*
store <4 x float> %783, <4 x float>* %785
%786 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%787 = bitcast float* %786 to <4 x float>*
%788 = load <4 x float>, <4 x float>* %787
%789 = getelementptr inbounds float, float* %503, i64 76
%790 = bitcast float* %789 to <4 x float>*
%791 = load <4 x float>, <4 x float>* %790
%792 = fmul <4 x float> %596, %791
%793 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %598, <4 x float> %788, <4 x float> %792)
%794 = getelementptr inbounds float, float* %0, i64 76
%795 = bitcast float* %794 to <4 x float>*
store <4 x float> %793, <4 x float>* %795
br label %815
796: ; preds = %585, %796
%797 = phi i64 [ %813, %796 ], [ 0, %585 ]
%798 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %797
%799 = load float, float* %798
%800 = getelementptr inbounds float, float* %503, i64 %797
%801 = load float, float* %800
%802 = fmul float %587, %801
%803 = tail call float @llvm.fmuladd.f32(float %586, float %799, float %802)
%804 = getelementptr inbounds float, float* %0, i64 %797
store float %803, float* %804
%805 = or i64 %797, 1
%806 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %805
%807 = load float, float* %806
%808 = getelementptr inbounds float, float* %503, i64 %805
%809 = load float, float* %808
%810 = fmul float %587, %809
%811 = tail call float @llvm.fmuladd.f32(float %586, float %807, float %810)
%812 = getelementptr inbounds float, float* %0, i64 %805
store float %811, float* %812
%813 = add nuw nsw i64 %797, 2
%814 = icmp eq i64 %813, 80
br i1 %814, label %815, label %796
815: ; preds = %796, %594, %559
ret void
}