#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 */
float cosf(float);
float fabsf(float);
float sqrtf(float);
void smath(float *odata, float *sseq, int hl, float alpha0) {
  int i;
  int k;
  float w00;
  float w10;
  float w11;
  float A;
  float B;
  float C;
  float *psseq;
  float err, errs;
  float surround[240];
  float wt[2 * 3 + 1];
  float denom;
  for (i = 1; i <= 2 * hl + 1; i++)
    wt[i - 1] =
        0.5f *
        (1.0f - cosf(2.0f * 3.14159265358979323846f * i / (2.0f * hl + 2.0f)));
  wt[hl] = 0.0f;
  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.0f;
  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 (fabsf(w11) < 1.0f)
    w11 = 1.0f;
  C = sqrtf(w00 / w11);
  errs = 0.0f;
  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.0001f) {
      A = sqrtf((alpha0 - alpha0 * alpha0 / 4) / denom);
      B = -alpha0 / 2.0f - A * w10 / w00;
      B = B + 1.0f;
    } else {
      A = 0.0f;
      B = 1.0f;
    }
    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     11bc <smath+0x9c>
cvtsi2ssl -0x1c(%rbp),%xmm1
movss  0xeb1(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
addss  %xmm1,%xmm1
movss  0xe90(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
call   1030 <cosf@plt>
movss  0xe73(%rip),%xmm1
subss  %xmm0,%xmm1
movss  0xe77(%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    1142 <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    120d <smath+0xed>
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    11d3 <smath+0xb3>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a0 <smath+0x180>
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    128d <smath+0x16d>
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    123d <smath+0x11d>
jmp    1292 <smath+0x172>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1214 <smath+0xf4>
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     133a <smath+0x21a>
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    1327 <smath+0x207>
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    12d7 <smath+0x1b7>
jmp    132c <smath+0x20c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12a9 <smath+0x189>
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    140b <smath+0x2eb>
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    136f <smath+0x24f>
movss  -0x2c(%rbp),%xmm1
movaps 0xc09(%rip),%xmm0
pand   %xmm0,%xmm1
movss  0xbdd(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1439 <smath+0x319>
movss  0xbcc(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x24(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
call   1040 <sqrtf@plt>
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    14e4 <smath+0x3c4>
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    1472 <smath+0x352>
movss  -0x48(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1679 <smath+0x559>
movss  0xafc(%rip),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    151b <smath+0x3fb>
movss  0xaea(%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
movss  0xa9a(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    15f1 <smath+0x4d1>
movss  -0x18(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movss  0xa82(%rip),%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
divss  -0x434(%rbp),%xmm0
ff
call   1040 <sqrtf@plt>
movss  %xmm0,-0x30(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  0xa4a(%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  0xa1e(%rip),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1606 <smath+0x4e6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  0x9ff(%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    1674 <smath+0x554>
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    1623 <smath+0x503>
jmp    1679 <smath+0x559>
add    $0x440,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<smath>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x478,%rsp
movss  %xmm0,0x2c(%rsp)
mov    %rsi,%r14
mov    %rdi,%r13
lea    (%rdx,%rdx,1),%ebp
lea    (%rdx,%rdx,1),%eax
add    $0x1,%eax
test   %eax,%eax
jle    1269 <smath+0x149>
cvtsi2ss %edx,%xmm1
addss  %xmm1,%xmm1
addss  0xea2(%rip),%xmm1
test   %ebp,%ebp
mov    %rdx,0xa8(%rsp)
mov    %rbp,0xa0(%rsp)
je     1222 <smath+0x102>
add    $0x2,%ebp
add    $0xfffffffffffffffe,%rbp
mov    $0x1,%ebx
mov    $0x2,%r12d
xor    %r15d,%r15d
movss  %xmm1,(%rsp)
lea    -0x1(%r12),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0xe60(%rip),%xmm2
mulss  %xmm2,%xmm0
divss  %xmm1,%xmm0
call   1030 <cosf@plt>
movss  0xe4f(%rip),%xmm1
subss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %r12d,%xmm0
movss  0xe3f(%rip),%xmm2
mulss  %xmm2,%xmm1
movss  %xmm1,0x7c(%rsp,%rbx,4)
mulss  0xe25(%rip),%xmm0
divss  (%rsp),%xmm0
call   1030 <cosf@plt>
movss  0xe17(%rip),%xmm1
subss  %xmm0,%xmm1
mulss  0xe0f(%rip),%xmm1
movss  %xmm1,0x80(%rsp,%rbx,4)
movss  (%rsp),%xmm1
add    $0x2,%rbx
add    $0x2,%r15
add    $0x2,%r12d
cmp    %rbp,%r15
jne    1190 <smath+0x70>
jmp    1227 <smath+0x107>
mov    $0x1,%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  0xdce(%rip),%xmm0
divss  %xmm1,%xmm0
call   1030 <cosf@plt>
movss  0xdc1(%rip),%xmm1
subss  %xmm0,%xmm1
mulss  0xdb9(%rip),%xmm1
movss  %xmm1,0x7c(%rsp,%rbx,4)
mov    0xa8(%rsp),%rdx
mov    0xa0(%rsp),%rbp
movslq %edx,%rax
movl   $0x0,0x80(%rsp,%rax,4)
movaps 0x80(%rsp),%xmm0
shufps $0x0,%xmm0,%xmm0
movups (%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xb0(%rsp)
movups 0x10(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xc0(%rsp)
movups 0x20(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xd0(%rsp)
movups 0x30(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xe0(%rsp)
movups 0x40(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0xf0(%rsp)
movups 0x50(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x100(%rsp)
movups 0x60(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x110(%rsp)
movups 0x70(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x120(%rsp)
movups 0x80(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x130(%rsp)
movups 0x90(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x140(%rsp)
movups 0xa0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x150(%rsp)
movups 0xb0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x160(%rsp)
movups 0xc0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x170(%rsp)
movups 0xd0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x180(%rsp)
movups 0xe0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x190(%rsp)
movups 0xf0(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1a0(%rsp)
movups 0x100(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1b0(%rsp)
movups 0x110(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1c0(%rsp)
movups 0x120(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1d0(%rsp)
movups 0x130(%r14),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,0x1e0(%rsp)
cmp    $0x2,%edx
jl     16f9 <smath+0x5d9>
mov    %edx,%ecx
movaps 0xb0(%rsp),%xmm8
movaps 0xc0(%rsp),%xmm7
movaps 0xd0(%rsp),%xmm10
movaps 0xe0(%rsp),%xmm12
movaps 0xf0(%rsp),%xmm11
movaps 0x100(%rsp),%xmm9
movaps 0x110(%rsp),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0x120(%rsp),%xmm15
movaps 0x130(%rsp),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0x140(%rsp),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x150(%rsp),%xmm3
movaps 0x160(%rsp),%xmm2
movaps 0x170(%rsp),%xmm1
movaps 0x180(%rsp),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x190(%rsp),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0x1a0(%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x270(%r14),%rdi
mov    $0x1,%esi
movaps 0x1b0(%rsp),%xmm6
movaps 0x1c0(%rsp),%xmm13
movaps 0x1d0(%rsp),%xmm14
movaps 0x1e0(%rsp),%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm5,(%rsp)
movss  0x80(%rsp,%rsi,4),%xmm4
shufps $0x0,%xmm4,%xmm4
movups -0x130(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm8
movups -0x120(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm7
movups -0x110(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm10
movups -0x100(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm12
movups -0xf0(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm11
movups -0xe0(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm9
movups -0xd0(%rdi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x40(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x40(%rsp)
movups -0xc0(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm15
movups -0xb0(%rdi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x60(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x60(%rsp)
movups -0xa0(%rdi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x50(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x50(%rsp)
movups -0x90(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm3
movups -0x80(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm2
movups -0x70(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm1
movups -0x60(%rdi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x70(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x70(%rsp)
movups -0x50(%rdi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x30(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x30(%rsp)
movups -0x40(%rdi),%xmm5
mulps  %xmm4,%xmm5
movaps %xmm6,%xmm0
movaps 0x10(%rsp),%xmm6
addps  %xmm5,%xmm6
movaps %xmm6,0x10(%rsp)
movaps %xmm0,%xmm6
movups -0x30(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm6
movups -0x20(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm13
movups -0x10(%rdi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm14
movups (%rdi),%xmm5
mulps  %xmm4,%xmm5
movaps (%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,(%rsp)
movaps (%rsp),%xmm5
add    $0x1,%rsi
add    $0x140,%rdi
cmp    %rsi,%rcx
jne    14d0 <smath+0x3b0>
movaps %xmm8,0xb0(%rsp)
movaps %xmm7,0xc0(%rsp)
movaps %xmm10,0xd0(%rsp)
movaps %xmm12,0xe0(%rsp)
movaps %xmm11,0xf0(%rsp)
movaps %xmm9,0x100(%rsp)
movaps 0x40(%rsp),%xmm0
movaps %xmm0,0x110(%rsp)
movaps %xmm15,0x120(%rsp)
movaps 0x60(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
movaps 0x50(%rsp),%xmm0
movaps %xmm0,0x140(%rsp)
movaps %xmm3,0x150(%rsp)
movaps %xmm2,0x160(%rsp)
movaps %xmm1,0x170(%rsp)
movaps 0x70(%rsp),%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0x30(%rsp),%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0x10(%rsp),%xmm4
movaps %xmm4,0x1a0(%rsp)
movaps %xmm6,0x1b0(%rsp)
movaps %xmm13,0x1c0(%rsp)
movaps %xmm14,0x1d0(%rsp)
movaps %xmm5,0x1e0(%rsp)
cmp    %edx,%ebp
jle    1a09 <smath+0x8e9>
movslq %ebp,%rcx
movaps 0xb0(%rsp),%xmm8
movaps 0xc0(%rsp),%xmm7
movaps 0xd0(%rsp),%xmm10
movaps 0xe0(%rsp),%xmm12
movaps 0xf0(%rsp),%xmm11
movaps 0x100(%rsp),%xmm9
movaps 0x110(%rsp),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0x120(%rsp),%xmm15
movaps 0x130(%rsp),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0x140(%rsp),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x150(%rsp),%xmm3
movaps 0x160(%rsp),%xmm2
movaps 0x170(%rsp),%xmm1
movaps 0x180(%rsp),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x190(%rsp),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0x1a0(%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
lea    (%rax,%rax,4),%rsi
shl    $0x6,%rsi
add    %r14,%rsi
add    $0x270,%rsi
movaps 0x1b0(%rsp),%xmm6
movaps 0x1c0(%rsp),%xmm13
movaps 0x1d0(%rsp),%xmm14
movaps 0x1e0(%rsp),%xmm5
nopl   0x0(%rax)
movaps %xmm5,(%rsp)
movss  0x84(%rsp,%rax,4),%xmm4
shufps $0x0,%xmm4,%xmm4
movups -0x130(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm8
movups -0x120(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm7
movups -0x110(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm10
movups -0x100(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm12
movups -0xf0(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm11
movups -0xe0(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm9
movups -0xd0(%rsi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x40(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x40(%rsp)
movups -0xc0(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm15
movups -0xb0(%rsi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x60(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x60(%rsp)
movups -0xa0(%rsi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x50(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x50(%rsp)
movups -0x90(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm3
movups -0x80(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm2
movups -0x70(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm1
movups -0x60(%rsi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x70(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x70(%rsp)
movups -0x50(%rsi),%xmm5
mulps  %xmm4,%xmm5
movaps 0x30(%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,0x30(%rsp)
movups -0x40(%rsi),%xmm5
mulps  %xmm4,%xmm5
movaps %xmm6,%xmm0
movaps 0x10(%rsp),%xmm6
addps  %xmm5,%xmm6
movaps %xmm6,0x10(%rsp)
movaps %xmm0,%xmm6
movups -0x30(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm6
movups -0x20(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm13
movups -0x10(%rsi),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm5,%xmm14
movups (%rsi),%xmm5
mulps  %xmm4,%xmm5
movaps (%rsp),%xmm0
addps  %xmm5,%xmm0
movaps %xmm0,(%rsp)
movaps (%rsp),%xmm5
add    $0x1,%rax
add    $0x140,%rsi
cmp    %rax,%rcx
jne    17e0 <smath+0x6c0>
movaps %xmm8,0xb0(%rsp)
movaps %xmm7,0xc0(%rsp)
movaps %xmm10,0xd0(%rsp)
movaps %xmm12,0xe0(%rsp)
movaps %xmm11,0xf0(%rsp)
movaps %xmm9,0x100(%rsp)
movaps 0x40(%rsp),%xmm0
movaps %xmm0,0x110(%rsp)
movaps %xmm15,0x120(%rsp)
movaps 0x60(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
movaps 0x50(%rsp),%xmm0
movaps %xmm0,0x140(%rsp)
movaps %xmm3,0x150(%rsp)
movaps %xmm2,0x160(%rsp)
movaps %xmm1,0x170(%rsp)
movaps 0x70(%rsp),%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0x30(%rsp),%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0x10(%rsp),%xmm4
movaps %xmm4,0x1a0(%rsp)
movaps %xmm6,0x1b0(%rsp)
movaps %xmm13,0x1c0(%rsp)
movaps %xmm14,0x1d0(%rsp)
movaps %xmm5,0x1e0(%rsp)
shl    $0x4,%edx
lea    (%rdx,%rdx,4),%eax
movslq %eax,%r15
lea    (%r14,%r15,4),%rbx
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rax,4),%xmm0
movss  0xac(%rsp,%rax,4),%xmm1
movaps %xmm1,%xmm2
unpcklps %xmm0,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm5,%xmm0
movss  (%rbx,%rax,4),%xmm3
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm1
addps  %xmm4,%xmm1
movss  0xb0(%rsp,%rax,4),%xmm2
movaps %xmm2,%xmm4
unpcklps %xmm3,%xmm2
movaps %xmm3,%xmm5
mulss  %xmm3,%xmm5
addss  %xmm0,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm2
movaps %xmm2,%xmm4
addps  %xmm1,%xmm4
add    $0x2,%rax
cmp    $0x51,%rax
jne    1a30 <smath+0x910>
movaps 0x58c(%rip),%xmm6
andps  %xmm4,%xmm6
movss  0x569(%rip),%xmm3
cmpltss %xmm3,%xmm6
movaps %xmm6,%xmm0
andps  %xmm3,%xmm0
andnps %xmm4,%xmm6
orps   %xmm0,%xmm6
movaps %xmm5,%xmm0
divss  %xmm6,%xmm0
xorps  %xmm7,%xmm7
ucomiss %xmm7,%xmm0
jb     1ac5 <smath+0x9a5>
sqrtss %xmm0,%xmm0
jmp    1af1 <smath+0x9d1>
movaps %xmm4,(%rsp)
movaps %xmm5,0x10(%rsp)
movaps %xmm6,0x30(%rsp)
call   1040 <sqrtf@plt>
xorps  %xmm7,%xmm7
movaps 0x30(%rsp),%xmm6
movaps 0x10(%rsp),%xmm5
movaps (%rsp),%xmm4
movss  0x517(%rip),%xmm3
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
movss  0xac(%rsp,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r13,%rax,4)
movss  -0x4(%rbx,%rax,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm7,%xmm2
movss  0xb0(%rsp,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
movss  (%rbx,%rax,4),%xmm7
subss  %xmm1,%xmm7
mulss  %xmm7,%xmm7
addss  %xmm2,%xmm7
add    $0x2,%rax
cmp    $0x51,%rax
jne    1b00 <smath+0x9e0>
movaps %xmm5,%xmm0
movss  0x2c(%rsp),%xmm2
mulss  %xmm2,%xmm0
ucomiss %xmm0,%xmm7
jbe    1ec6 <smath+0xda6>
movaps %xmm3,%xmm7
maxss  %xmm5,%xmm7
shufps $0x55,%xmm4,%xmm4
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm0
mulss  %xmm7,%xmm6
subss  %xmm0,%xmm6
movaps %xmm7,%xmm0
mulss  %xmm7,%xmm0
divss  %xmm0,%xmm6
xorps  %xmm0,%xmm0
ucomiss 0x476(%rip),%xmm6
jbe    1bfd <smath+0xadd>
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
mulss  0x469(%rip),%xmm0
addss  %xmm2,%xmm0
divss  %xmm6,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1bc1 <smath+0xaa1>
sqrtss %xmm0,%xmm0
jmp    1bde <smath+0xabe>
movaps %xmm4,(%rsp)
movaps %xmm7,0x10(%rsp)
call   1040 <sqrtf@plt>
movaps 0x10(%rsp),%xmm7
movaps (%rsp),%xmm4
movss  0x2c(%rsp),%xmm2
mulss  0x432(%rip),%xmm2
mulss  %xmm0,%xmm4
divss  %xmm7,%xmm4
subss  %xmm4,%xmm2
addss  0x40e(%rip),%xmm2
movaps %xmm2,%xmm3
lea    (%r14,%r15,4),%rax
add    $0x140,%rax
cmp    %r13,%rax
jbe    1c72 <smath+0xb52>
lea    0x140(%r13),%rax
cmp    %rax,%rbx
jae    1c72 <smath+0xb52>
mov    $0x1,%eax
nopl   (%rax)
movss  -0x4(%rbx,%rax,4),%xmm1
mulss  %xmm3,%xmm1
movss  0xac(%rsp,%rax,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x4(%r13,%rax,4)
movss  (%rbx,%rax,4),%xmm1
mulss  %xmm3,%xmm1
movss  0xb0(%rsp,%rax,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x0(%r13,%rax,4)
add    $0x2,%rax
cmp    $0x51,%rax
jne    1c20 <smath+0xb00>
jmp    1ec6 <smath+0xda6>
shufps $0x0,%xmm3,%xmm3
shufps $0x0,%xmm0,%xmm0
movups (%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0xb0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x0(%r13)
movups 0x10(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0xc0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x10(%r13)
movups 0x20(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0xd0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x20(%r13)
movups 0x30(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0xe0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x30(%r13)
movups 0x40(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0xf0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x40(%r13)
movups 0x50(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x100(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x50(%r13)
movups 0x60(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x110(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x60(%r13)
movups 0x70(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x120(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x70(%r13)
movups 0x80(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x130(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x80(%r13)
movups 0x90(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x140(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x90(%r13)
movups 0xa0(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x150(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xa0(%r13)
movups 0xb0(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x160(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xb0(%r13)
movups 0xc0(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x170(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xc0(%r13)
movups 0xd0(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x180(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xd0(%r13)
movups 0xe0(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x190(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xe0(%r13)
movups 0xf0(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x1a0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xf0(%r13)
movups 0x100(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x1b0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x100(%r13)
movups 0x110(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x1c0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x110(%r13)
movups 0x120(%rbx),%xmm1
mulps  %xmm3,%xmm1
movaps 0x1d0(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x120(%r13)
movups 0x130(%rbx),%xmm1
mulps  %xmm3,%xmm1
mulps  0x1e0(%rsp),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,0x130(%r13)
add    $0x478,%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 = %44, %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 %47
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 = sitofp i32 %33 to float
%35 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %34, float 2.000000e+00)
%36 = fdiv float %32, %35
%37 = call float @cosf(float %36)
%38 = fsub float 1.000000e+00, %37
%39 = fmul float 5.000000e-01, %38
%40 = load i32, i32* %9
%41 = sub nsw i32 %40, 1
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [7 x float], [7 x float]* %21, i64 0, i64 %42
store float %39, float* %43
br label %44
44: ; preds = %29
%45 = load i32, i32* %9
%46 = add nsw i32 %45, 1
store i32 %46, i32* %9
br label %23
47: ; preds = %23
%48 = load i32, i32* %7
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [7 x float], [7 x float]* %21, i64 0, i64 %49
store float 0.000000e+00, float* %50
store i32 0, i32* %9
br label %51
51: ; preds = %66, %47
%52 = load i32, i32* %9
%53 = icmp slt i32 %52, 80
br i1 %53, label %54, label %69
54: ; preds = %51
%55 = load float*, float** %6
%56 = load i32, i32* %9
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %55, i64 %57
%59 = load float, float* %58
%60 = getelementptr inbounds [7 x float], [7 x float]* %21, i64 0, i64 0
%61 = load float, float* %60
%62 = fmul float %59, %61
%63 = load i32, i32* %9
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %64
store float %62, float* %65
br label %66
66: ; preds = %54
%67 = load i32, i32* %9
%68 = add nsw i32 %67, 1
store i32 %68, i32* %9
br label %51
69: ; preds = %51
store i32 1, i32* %10
br label %70
70: ; preds = %102, %69
%71 = load i32, i32* %10
%72 = load i32, i32* %7
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %105
74: ; preds = %70
%75 = load float*, float** %6
%76 = load i32, i32* %10
%77 = mul nsw i32 %76, 80
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %75, i64 %78
store float* %79, float** %17
store i32 0, i32* %9
br label %80
80: ; preds = %98, %74
%81 = load i32, i32* %9
%82 = icmp slt i32 %81, 80
br i1 %82, label %83, label %101
83: ; preds = %80
%84 = load float*, float** %17
%85 = load i32, i32* %9
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %84, i64 %86
%88 = load float, float* %87
%89 = load i32, i32* %10
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [7 x float], [7 x float]* %21, i64 0, i64 %90
%92 = load float, float* %91
%93 = load i32, i32* %9
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %94
%96 = load float, float* %95
%97 = call float @llvm.fmuladd.f32(float %88, float %92, float %96)
store float %97, float* %95
br label %98
98: ; preds = %83
%99 = load i32, i32* %9
%100 = add nsw i32 %99, 1
store i32 %100, i32* %9
br label %80
101: ; preds = %80
br label %102
102: ; preds = %101
%103 = load i32, i32* %10
%104 = add nsw i32 %103, 1
store i32 %104, i32* %10
br label %70
105: ; preds = %70
%106 = load i32, i32* %7
%107 = add nsw i32 %106, 1
store i32 %107, i32* %10
br label %108
108: ; preds = %141, %105
%109 = load i32, i32* %10
%110 = load i32, i32* %7
%111 = mul nsw i32 2, %110
%112 = icmp sle i32 %109, %111
br i1 %112, label %113, label %144
113: ; preds = %108
%114 = load float*, float** %6
%115 = load i32, i32* %10
%116 = mul nsw i32 %115, 80
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %114, i64 %117
store float* %118, float** %17
store i32 0, i32* %9
br label %119
119: ; preds = %137, %113
%120 = load i32, i32* %9
%121 = icmp slt i32 %120, 80
br i1 %121, label %122, label %140
122: ; preds = %119
%123 = load float*, float** %17
%124 = load i32, i32* %9
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %123, i64 %125
%127 = load float, float* %126
%128 = load i32, i32* %10
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [7 x float], [7 x float]* %21, i64 0, i64 %129
%131 = load float, float* %130
%132 = load i32, i32* %9
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %133
%135 = load float, float* %134
%136 = call float @llvm.fmuladd.f32(float %127, float %131, float %135)
store float %136, float* %134
br label %137
137: ; preds = %122
%138 = load i32, i32* %9
%139 = add nsw i32 %138, 1
store i32 %139, i32* %9
br label %119
140: ; preds = %119
br label %141
141: ; preds = %140
%142 = load i32, i32* %10
%143 = add nsw i32 %142, 1
store i32 %143, i32* %10
br label %108
144: ; preds = %108
store float 0.000000e+00, float* %13
store float 0.000000e+00, float* %12
store float 0.000000e+00, float* %11
%145 = load float*, float** %6
%146 = load i32, i32* %7
%147 = mul nsw i32 %146, 80
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %145, i64 %148
store float* %149, float** %17
store i32 0, i32* %9
br label %150
150: ; preds = %187, %144
%151 = load i32, i32* %9
%152 = icmp slt i32 %151, 80
br i1 %152, label %153, label %190
153: ; preds = %150
%154 = load float*, float** %17
%155 = load i32, i32* %9
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float, float* %154, i64 %156
%158 = load float, float* %157
%159 = load float*, float** %17
%160 = load i32, i32* %9
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float, float* %159, i64 %161
%163 = load float, float* %162
%164 = load float, float* %11
%165 = call float @llvm.fmuladd.f32(float %158, float %163, float %164)
store float %165, float* %11
%166 = load i32, i32* %9
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %167
%169 = load float, float* %168
%170 = load i32, i32* %9
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %171
%173 = load float, float* %172
%174 = load float, float* %13
%175 = call float @llvm.fmuladd.f32(float %169, float %173, float %174)
store float %175, float* %13
%176 = load i32, i32* %9
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %177
%179 = load float, float* %178
%180 = load float*, float** %17
%181 = load i32, i32* %9
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
%184 = load float, float* %183
%185 = load float, float* %12
%186 = call float @llvm.fmuladd.f32(float %179, float %184, float %185)
store float %186, float* %12
br label %187
187: ; preds = %153
%188 = load i32, i32* %9
%189 = add nsw i32 %188, 1
store i32 %189, i32* %9
br label %150
190: ; preds = %150
%191 = load float, float* %13
%192 = call float @llvm.fabs.f32(float %191)
%193 = fcmp olt float %192, 1.000000e+00
br i1 %193, label %194, label %195
194: ; preds = %190
store float 1.000000e+00, float* %13
br label %195
195: ; preds = %194, %190
%196 = load float, float* %11
%197 = load float, float* %13
%198 = fdiv float %196, %197
%199 = call float @sqrtf(float %198)
store float %199, float* %16
store float 0.000000e+00, float* %19
%200 = load float*, float** %6
%201 = load i32, i32* %7
%202 = mul nsw i32 %201, 80
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %200, i64 %203
store float* %204, float** %17
store i32 0, i32* %9
br label %205
205: ; preds = %234, %195
%206 = load i32, i32* %9
%207 = icmp slt i32 %206, 80
br i1 %207, label %208, label %237
208: ; preds = %205
%209 = load float, float* %16
%210 = load i32, i32* %9
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %211
%213 = load float, float* %212
%214 = fmul float %209, %213
%215 = load float*, float** %5
%216 = load i32, i32* %9
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %215, i64 %217
store float %214, float* %218
%219 = load float*, float** %17
%220 = load i32, i32* %9
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %219, i64 %221
%223 = load float, float* %222
%224 = load float*, float** %5
%225 = load i32, i32* %9
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds float, float* %224, i64 %226
%228 = load float, float* %227
%229 = fsub float %223, %228
store float %229, float* %18
%230 = load float, float* %18
%231 = load float, float* %18
%232 = load float, float* %19
%233 = call float @llvm.fmuladd.f32(float %230, float %231, float %232)
store float %233, float* %19
br label %234
234: ; preds = %208
%235 = load i32, i32* %9
%236 = add nsw i32 %235, 1
store i32 %236, i32* %9
br label %205
237: ; preds = %205
%238 = load float, float* %19
%239 = load float, float* %8
%240 = load float, float* %11
%241 = fmul float %239, %240
%242 = fcmp ogt float %238, %241
br i1 %242, label %243, label %314
243: ; preds = %237
%244 = load float, float* %11
%245 = fcmp olt float %244, 1.000000e+00
br i1 %245, label %246, label %247
246: ; preds = %243
store float 1.000000e+00, float* %11
br label %247
247: ; preds = %246, %243
%248 = load float, float* %13
%249 = load float, float* %11
%250 = load float, float* %12
%251 = load float, float* %12
%252 = fmul float %250, %251
%253 = fneg float %252
%254 = call float @llvm.fmuladd.f32(float %248, float %249, float %253)
%255 = load float, float* %11
%256 = load float, float* %11
%257 = fmul float %255, %256
%258 = fdiv float %254, %257
store float %258, float* %22
%259 = load float, float* %22
%260 = fcmp ogt float %259, 0x3F1A36E2E0000000
br i1 %260, label %261, label %282
261: ; preds = %247
%262 = load float, float* %8
%263 = load float, float* %8
%264 = load float, float* %8
%265 = fmul float %263, %264
%266 = fdiv float %265, 4.000000e+00
%267 = fsub float %262, %266
%268 = load float, float* %22
%269 = fdiv float %267, %268
%270 = call float @sqrtf(float %269)
store float %270, float* %14
%271 = load float, float* %8
%272 = fneg float %271
%273 = fdiv float %272, 2.000000e+00
%274 = load float, float* %14
%275 = load float, float* %12
%276 = fmul float %274, %275
%277 = load float, float* %11
%278 = fdiv float %276, %277
%279 = fsub float %273, %278
store float %279, float* %15
%280 = load float, float* %15
%281 = fadd float %280, 1.000000e+00
store float %281, float* %15
br label %283
282: ; preds = %247
store float 0.000000e+00, float* %14
store float 1.000000e+00, float* %15
br label %283
283: ; preds = %282, %261
%284 = load float*, float** %6
%285 = load i32, i32* %7
%286 = mul nsw i32 %285, 80
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %284, i64 %287
store float* %288, float** %17
store i32 0, i32* %9
br label %289
289: ; preds = %310, %283
%290 = load i32, i32* %9
%291 = icmp slt i32 %290, 80
br i1 %291, label %292, label %313
292: ; preds = %289
%293 = load float, float* %14
%294 = load i32, i32* %9
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [240 x float], [240 x float]* %20, i64 0, i64 %295
%297 = load float, float* %296
%298 = load float, float* %15
%299 = load float*, float** %17
%300 = load i32, i32* %9
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %299, i64 %301
%303 = load float, float* %302
%304 = fmul float %298, %303
%305 = call float @llvm.fmuladd.f32(float %293, float %297, float %304)
%306 = load float*, float** %5
%307 = load i32, i32* %9
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds float, float* %306, i64 %308
store float %305, float* %309
br label %310
310: ; preds = %292
%311 = load i32, i32* %9
%312 = add nsw i32 %311, 1
store i32 %312, i32* %9
br label %289
313: ; preds = %289
br label %314
314: ; preds = %313, %237
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 %55, label %12
12: ; preds = %4
%13 = sitofp i32 %2 to float
%14 = tail call float @llvm.fmuladd.f32(float %13, float 2.000000e+00, float 2.000000e+00)
%15 = icmp eq i32 %9, 0
br i1 %15, label %44, label %16
16: ; preds = %12
%17 = add i32 %9, 2
%18 = zext i32 %17 to i64
%19 = add nsw i64 %18, -2
br label %20
20: ; preds = %20, %16
%21 = phi i64 [ 1, %16 ], [ %41, %20 ]
%22 = phi i64 [ 0, %16 ], [ %42, %20 ]
%23 = trunc i64 %21 to i32
%24 = sitofp i32 %23 to float
%25 = fmul float %24, 0x401921FB60000000
%26 = fdiv float %25, %14
%27 = tail call float @cosf(float %26)
%28 = fsub float 1.000000e+00, %27
%29 = fmul float %28, 5.000000e-01
%30 = add nsw i64 %21, -1
%31 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %30
store float %29, float* %31
%32 = trunc i64 %21 to i32
%33 = add i32 %32, 1
%34 = sitofp i32 %33 to float
%35 = fmul float %34, 0x401921FB60000000
%36 = fdiv float %35, %14
%37 = tail call float @cosf(float %36)
%38 = fsub float 1.000000e+00, %37
%39 = fmul float %38, 5.000000e-01
%40 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %21
store float %39, float* %40
%41 = add nuw nsw i64 %21, 2
%42 = add i64 %22, 2
%43 = icmp eq i64 %42, %19
br i1 %43, label %44, label %20
44: ; preds = %20, %12
%45 = phi i64 [ 1, %12 ], [ %41, %20 ]
%46 = trunc i64 %45 to i32
%47 = sitofp i32 %46 to float
%48 = fmul float %47, 0x401921FB60000000
%49 = fdiv float %48, %14
%50 = tail call float @cosf(float %49)
%51 = fsub float 1.000000e+00, %50
%52 = fmul float %51, 5.000000e-01
%53 = add nsw i64 %45, -1
%54 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %53
store float %52, float* %54
br label %55
55: ; preds = %44, %4
%56 = sext i32 %2 to i64
%57 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %56
store float 0.000000e+00, float* %57
%58 = bitcast [7 x float]* %6 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = shufflevector <4 x float> %59, <4 x float> poison, <4 x i32> zeroinitializer
%61 = bitcast float* %1 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = fmul <4 x float> %62, %60
%64 = bitcast [240 x float]* %5 to <4 x float>*
store <4 x float> %63, <4 x float>* %64
%65 = getelementptr inbounds float, float* %1, i64 4
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = fmul <4 x float> %67, %60
%69 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %68, <4 x float>* %70
%71 = getelementptr inbounds float, float* %1, i64 8
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = fmul <4 x float> %73, %60
%75 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%76 = bitcast float* %75 to <4 x float>*
store <4 x float> %74, <4 x float>* %76
%77 = getelementptr inbounds float, float* %1, i64 12
%78 = bitcast float* %77 to <4 x float>*
%79 = load <4 x float>, <4 x float>* %78
%80 = fmul <4 x float> %79, %60
%81 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %80, <4 x float>* %82
%83 = getelementptr inbounds float, float* %1, i64 16
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = fmul <4 x float> %85, %60
%87 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%88 = bitcast float* %87 to <4 x float>*
store <4 x float> %86, <4 x float>* %88
%89 = getelementptr inbounds float, float* %1, i64 20
%90 = bitcast float* %89 to <4 x float>*
%91 = load <4 x float>, <4 x float>* %90
%92 = fmul <4 x float> %91, %60
%93 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%94 = bitcast float* %93 to <4 x float>*
store <4 x float> %92, <4 x float>* %94
%95 = getelementptr inbounds float, float* %1, i64 24
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = fmul <4 x float> %97, %60
%99 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%100 = bitcast float* %99 to <4 x float>*
store <4 x float> %98, <4 x float>* %100
%101 = getelementptr inbounds float, float* %1, i64 28
%102 = bitcast float* %101 to <4 x float>*
%103 = load <4 x float>, <4 x float>* %102
%104 = fmul <4 x float> %103, %60
%105 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %104, <4 x float>* %106
%107 = getelementptr inbounds float, float* %1, i64 32
%108 = bitcast float* %107 to <4 x float>*
%109 = load <4 x float>, <4 x float>* %108
%110 = fmul <4 x float> %109, %60
%111 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%112 = bitcast float* %111 to <4 x float>*
store <4 x float> %110, <4 x float>* %112
%113 = getelementptr inbounds float, float* %1, i64 36
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = fmul <4 x float> %115, %60
%117 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%118 = bitcast float* %117 to <4 x float>*
store <4 x float> %116, <4 x float>* %118
%119 = getelementptr inbounds float, float* %1, i64 40
%120 = bitcast float* %119 to <4 x float>*
%121 = load <4 x float>, <4 x float>* %120
%122 = fmul <4 x float> %121, %60
%123 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%124 = bitcast float* %123 to <4 x float>*
store <4 x float> %122, <4 x float>* %124
%125 = getelementptr inbounds float, float* %1, i64 44
%126 = bitcast float* %125 to <4 x float>*
%127 = load <4 x float>, <4 x float>* %126
%128 = fmul <4 x float> %127, %60
%129 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%130 = bitcast float* %129 to <4 x float>*
store <4 x float> %128, <4 x float>* %130
%131 = getelementptr inbounds float, float* %1, i64 48
%132 = bitcast float* %131 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = fmul <4 x float> %133, %60
%135 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%136 = bitcast float* %135 to <4 x float>*
store <4 x float> %134, <4 x float>* %136
%137 = getelementptr inbounds float, float* %1, i64 52
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = fmul <4 x float> %139, %60
%141 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%142 = bitcast float* %141 to <4 x float>*
store <4 x float> %140, <4 x float>* %142
%143 = getelementptr inbounds float, float* %1, i64 56
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = fmul <4 x float> %145, %60
%147 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%148 = bitcast float* %147 to <4 x float>*
store <4 x float> %146, <4 x float>* %148
%149 = getelementptr inbounds float, float* %1, i64 60
%150 = bitcast float* %149 to <4 x float>*
%151 = load <4 x float>, <4 x float>* %150
%152 = fmul <4 x float> %151, %60
%153 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %152, <4 x float>* %154
%155 = getelementptr inbounds float, float* %1, i64 64
%156 = bitcast float* %155 to <4 x float>*
%157 = load <4 x float>, <4 x float>* %156
%158 = fmul <4 x float> %157, %60
%159 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%160 = bitcast float* %159 to <4 x float>*
store <4 x float> %158, <4 x float>* %160
%161 = getelementptr inbounds float, float* %1, i64 68
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = fmul <4 x float> %163, %60
%165 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%166 = bitcast float* %165 to <4 x float>*
store <4 x float> %164, <4 x float>* %166
%167 = getelementptr inbounds float, float* %1, i64 72
%168 = bitcast float* %167 to <4 x float>*
%169 = load <4 x float>, <4 x float>* %168
%170 = fmul <4 x float> %169, %60
%171 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%172 = bitcast float* %171 to <4 x float>*
store <4 x float> %170, <4 x float>* %172
%173 = getelementptr inbounds float, float* %1, i64 76
%174 = bitcast float* %173 to <4 x float>*
%175 = load <4 x float>, <4 x float>* %174
%176 = fmul <4 x float> %175, %60
%177 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%178 = bitcast float* %177 to <4 x float>*
store <4 x float> %176, <4 x float>* %178
%179 = icmp sgt i32 %2, 1
br i1 %179, label %180, label %242
180: ; preds = %55
%181 = zext i32 %2 to i64
%182 = bitcast [240 x float]* %5 to <4 x float>*
%183 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%184 = bitcast float* %183 to <4 x float>*
%185 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%186 = bitcast float* %185 to <4 x float>*
%187 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%188 = bitcast float* %187 to <4 x float>*
%189 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%190 = bitcast float* %189 to <4 x float>*
%191 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%192 = bitcast float* %191 to <4 x float>*
%193 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%194 = bitcast float* %193 to <4 x float>*
%195 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%196 = bitcast float* %195 to <4 x float>*
%197 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%198 = bitcast float* %197 to <4 x float>*
%199 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%200 = bitcast float* %199 to <4 x float>*
%201 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%202 = bitcast float* %201 to <4 x float>*
%203 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%204 = bitcast float* %203 to <4 x float>*
%205 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%206 = bitcast float* %205 to <4 x float>*
%207 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%208 = bitcast float* %207 to <4 x float>*
%209 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%210 = bitcast float* %209 to <4 x float>*
%211 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%212 = bitcast float* %211 to <4 x float>*
%213 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%214 = bitcast float* %213 to <4 x float>*
%215 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%216 = bitcast float* %215 to <4 x float>*
%217 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%218 = bitcast float* %217 to <4 x float>*
%219 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%220 = bitcast float* %219 to <4 x float>*
%221 = load <4 x float>, <4 x float>* %182
%222 = load <4 x float>, <4 x float>* %184
%223 = load <4 x float>, <4 x float>* %186
%224 = load <4 x float>, <4 x float>* %188
%225 = load <4 x float>, <4 x float>* %190
%226 = load <4 x float>, <4 x float>* %192
%227 = load <4 x float>, <4 x float>* %194
%228 = load <4 x float>, <4 x float>* %196
%229 = load <4 x float>, <4 x float>* %198
%230 = load <4 x float>, <4 x float>* %200
%231 = load <4 x float>, <4 x float>* %202
%232 = load <4 x float>, <4 x float>* %204
%233 = load <4 x float>, <4 x float>* %206
%234 = load <4 x float>, <4 x float>* %208
%235 = load <4 x float>, <4 x float>* %210
%236 = load <4 x float>, <4 x float>* %212
%237 = load <4 x float>, <4 x float>* %214
%238 = load <4 x float>, <4 x float>* %216
%239 = load <4 x float>, <4 x float>* %218
%240 = load <4 x float>, <4 x float>* %220
br label %305
241: ; preds = %305
store <4 x float> %335, <4 x float>* %182
store <4 x float> %339, <4 x float>* %184
store <4 x float> %343, <4 x float>* %186
store <4 x float> %347, <4 x float>* %188
store <4 x float> %351, <4 x float>* %190
store <4 x float> %355, <4 x float>* %192
store <4 x float> %359, <4 x float>* %194
store <4 x float> %363, <4 x float>* %196
store <4 x float> %367, <4 x float>* %198
store <4 x float> %371, <4 x float>* %200
store <4 x float> %375, <4 x float>* %202
store <4 x float> %379, <4 x float>* %204
store <4 x float> %383, <4 x float>* %206
store <4 x float> %387, <4 x float>* %208
store <4 x float> %391, <4 x float>* %210
store <4 x float> %395, <4 x float>* %212
store <4 x float> %399, <4 x float>* %214
store <4 x float> %403, <4 x float>* %216
store <4 x float> %407, <4 x float>* %218
store <4 x float> %411, <4 x float>* %220
br label %242
242: ; preds = %241, %55
%243 = icmp sgt i32 %9, %2
br i1 %243, label %244, label %524
244: ; preds = %242
%245 = sext i32 %9 to i64
%246 = bitcast [240 x float]* %5 to <4 x float>*
%247 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%248 = bitcast float* %247 to <4 x float>*
%249 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%250 = bitcast float* %249 to <4 x float>*
%251 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%252 = bitcast float* %251 to <4 x float>*
%253 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%254 = bitcast float* %253 to <4 x float>*
%255 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%256 = bitcast float* %255 to <4 x float>*
%257 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%258 = bitcast float* %257 to <4 x float>*
%259 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%260 = bitcast float* %259 to <4 x float>*
%261 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%262 = bitcast float* %261 to <4 x float>*
%263 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%264 = bitcast float* %263 to <4 x float>*
%265 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%266 = bitcast float* %265 to <4 x float>*
%267 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%268 = bitcast float* %267 to <4 x float>*
%269 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%270 = bitcast float* %269 to <4 x float>*
%271 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%272 = bitcast float* %271 to <4 x float>*
%273 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%274 = bitcast float* %273 to <4 x float>*
%275 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%276 = bitcast float* %275 to <4 x float>*
%277 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%278 = bitcast float* %277 to <4 x float>*
%279 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%280 = bitcast float* %279 to <4 x float>*
%281 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%282 = bitcast float* %281 to <4 x float>*
%283 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%284 = bitcast float* %283 to <4 x float>*
%285 = load <4 x float>, <4 x float>* %246
%286 = load <4 x float>, <4 x float>* %248
%287 = load <4 x float>, <4 x float>* %250
%288 = load <4 x float>, <4 x float>* %252
%289 = load <4 x float>, <4 x float>* %254
%290 = load <4 x float>, <4 x float>* %256
%291 = load <4 x float>, <4 x float>* %258
%292 = load <4 x float>, <4 x float>* %260
%293 = load <4 x float>, <4 x float>* %262
%294 = load <4 x float>, <4 x float>* %264
%295 = load <4 x float>, <4 x float>* %266
%296 = load <4 x float>, <4 x float>* %268
%297 = load <4 x float>, <4 x float>* %270
%298 = load <4 x float>, <4 x float>* %272
%299 = load <4 x float>, <4 x float>* %274
%300 = load <4 x float>, <4 x float>* %276
%301 = load <4 x float>, <4 x float>* %278
%302 = load <4 x float>, <4 x float>* %280
%303 = load <4 x float>, <4 x float>* %282
%304 = load <4 x float>, <4 x float>* %284
br label %414
305: ; preds = %180, %305
%306 = phi <4 x float> [ %240, %180 ], [ %411, %305 ]
%307 = phi <4 x float> [ %239, %180 ], [ %407, %305 ]
%308 = phi <4 x float> [ %238, %180 ], [ %403, %305 ]
%309 = phi <4 x float> [ %237, %180 ], [ %399, %305 ]
%310 = phi <4 x float> [ %236, %180 ], [ %395, %305 ]
%311 = phi <4 x float> [ %235, %180 ], [ %391, %305 ]
%312 = phi <4 x float> [ %234, %180 ], [ %387, %305 ]
%313 = phi <4 x float> [ %233, %180 ], [ %383, %305 ]
%314 = phi <4 x float> [ %232, %180 ], [ %379, %305 ]
%315 = phi <4 x float> [ %231, %180 ], [ %375, %305 ]
%316 = phi <4 x float> [ %230, %180 ], [ %371, %305 ]
%317 = phi <4 x float> [ %229, %180 ], [ %367, %305 ]
%318 = phi <4 x float> [ %228, %180 ], [ %363, %305 ]
%319 = phi <4 x float> [ %227, %180 ], [ %359, %305 ]
%320 = phi <4 x float> [ %226, %180 ], [ %355, %305 ]
%321 = phi <4 x float> [ %225, %180 ], [ %351, %305 ]
%322 = phi <4 x float> [ %224, %180 ], [ %347, %305 ]
%323 = phi <4 x float> [ %223, %180 ], [ %343, %305 ]
%324 = phi <4 x float> [ %222, %180 ], [ %339, %305 ]
%325 = phi <4 x float> [ %221, %180 ], [ %335, %305 ]
%326 = phi i64 [ 1, %180 ], [ %412, %305 ]
%327 = mul nuw nsw i64 %326, 80
%328 = getelementptr inbounds float, float* %1, i64 %327
%329 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %326
%330 = load float, float* %329
%331 = insertelement <4 x float> poison, float %330, i64 0
%332 = shufflevector <4 x float> %331, <4 x float> poison, <4 x i32> zeroinitializer
%333 = bitcast float* %328 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> %332, <4 x float> %325)
%336 = getelementptr inbounds float, float* %328, i64 4
%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> %332, <4 x float> %324)
%340 = getelementptr inbounds float, float* %328, i64 8
%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> %332, <4 x float> %323)
%344 = getelementptr inbounds float, float* %328, i64 12
%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> %332, <4 x float> %322)
%348 = getelementptr inbounds float, float* %328, i64 16
%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> %332, <4 x float> %321)
%352 = getelementptr inbounds float, float* %328, i64 20
%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> %332, <4 x float> %320)
%356 = getelementptr inbounds float, float* %328, i64 24
%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> %332, <4 x float> %319)
%360 = getelementptr inbounds float, float* %328, i64 28
%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> %332, <4 x float> %318)
%364 = getelementptr inbounds float, float* %328, i64 32
%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> %332, <4 x float> %317)
%368 = getelementptr inbounds float, float* %328, i64 36
%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> %332, <4 x float> %316)
%372 = getelementptr inbounds float, float* %328, i64 40
%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> %332, <4 x float> %315)
%376 = getelementptr inbounds float, float* %328, i64 44
%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> %332, <4 x float> %314)
%380 = getelementptr inbounds float, float* %328, i64 48
%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> %332, <4 x float> %313)
%384 = getelementptr inbounds float, float* %328, i64 52
%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> %332, <4 x float> %312)
%388 = getelementptr inbounds float, float* %328, i64 56
%389 = bitcast float* %388 to <4 x float>*
%390 = load <4 x float>, <4 x float>* %389
%391 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %390, <4 x float> %332, <4 x float> %311)
%392 = getelementptr inbounds float, float* %328, i64 60
%393 = bitcast float* %392 to <4 x float>*
%394 = load <4 x float>, <4 x float>* %393
%395 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %394, <4 x float> %332, <4 x float> %310)
%396 = getelementptr inbounds float, float* %328, i64 64
%397 = bitcast float* %396 to <4 x float>*
%398 = load <4 x float>, <4 x float>* %397
%399 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %398, <4 x float> %332, <4 x float> %309)
%400 = getelementptr inbounds float, float* %328, i64 68
%401 = bitcast float* %400 to <4 x float>*
%402 = load <4 x float>, <4 x float>* %401
%403 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %402, <4 x float> %332, <4 x float> %308)
%404 = getelementptr inbounds float, float* %328, i64 72
%405 = bitcast float* %404 to <4 x float>*
%406 = load <4 x float>, <4 x float>* %405
%407 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %406, <4 x float> %332, <4 x float> %307)
%408 = getelementptr inbounds float, float* %328, i64 76
%409 = bitcast float* %408 to <4 x float>*
%410 = load <4 x float>, <4 x float>* %409
%411 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %410, <4 x float> %332, <4 x float> %306)
%412 = add nuw nsw i64 %326, 1
%413 = icmp eq i64 %412, %181
br i1 %413, label %241, label %305
414: ; preds = %244, %414
%415 = phi <4 x float> [ %304, %244 ], [ %521, %414 ]
%416 = phi <4 x float> [ %303, %244 ], [ %517, %414 ]
%417 = phi <4 x float> [ %302, %244 ], [ %513, %414 ]
%418 = phi <4 x float> [ %301, %244 ], [ %509, %414 ]
%419 = phi <4 x float> [ %300, %244 ], [ %505, %414 ]
%420 = phi <4 x float> [ %299, %244 ], [ %501, %414 ]
%421 = phi <4 x float> [ %298, %244 ], [ %497, %414 ]
%422 = phi <4 x float> [ %297, %244 ], [ %493, %414 ]
%423 = phi <4 x float> [ %296, %244 ], [ %489, %414 ]
%424 = phi <4 x float> [ %295, %244 ], [ %485, %414 ]
%425 = phi <4 x float> [ %294, %244 ], [ %481, %414 ]
%426 = phi <4 x float> [ %293, %244 ], [ %477, %414 ]
%427 = phi <4 x float> [ %292, %244 ], [ %473, %414 ]
%428 = phi <4 x float> [ %291, %244 ], [ %469, %414 ]
%429 = phi <4 x float> [ %290, %244 ], [ %465, %414 ]
%430 = phi <4 x float> [ %289, %244 ], [ %461, %414 ]
%431 = phi <4 x float> [ %288, %244 ], [ %457, %414 ]
%432 = phi <4 x float> [ %287, %244 ], [ %453, %414 ]
%433 = phi <4 x float> [ %286, %244 ], [ %449, %414 ]
%434 = phi <4 x float> [ %285, %244 ], [ %445, %414 ]
%435 = phi i64 [ %56, %244 ], [ %436, %414 ]
%436 = add nsw i64 %435, 1
%437 = mul nsw i64 %436, 80
%438 = getelementptr inbounds float, float* %1, i64 %437
%439 = getelementptr inbounds [7 x float], [7 x float]* %6, i64 0, i64 %436
%440 = load float, float* %439
%441 = insertelement <4 x float> poison, float %440, i64 0
%442 = shufflevector <4 x float> %441, <4 x float> poison, <4 x i32> zeroinitializer
%443 = bitcast float* %438 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> %442, <4 x float> %434)
%446 = getelementptr inbounds float, float* %438, i64 4
%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> %442, <4 x float> %433)
%450 = getelementptr inbounds float, float* %438, i64 8
%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> %442, <4 x float> %432)
%454 = getelementptr inbounds float, float* %438, i64 12
%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> %442, <4 x float> %431)
%458 = getelementptr inbounds float, float* %438, i64 16
%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> %442, <4 x float> %430)
%462 = getelementptr inbounds float, float* %438, i64 20
%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> %442, <4 x float> %429)
%466 = getelementptr inbounds float, float* %438, i64 24
%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> %442, <4 x float> %428)
%470 = getelementptr inbounds float, float* %438, i64 28
%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> %442, <4 x float> %427)
%474 = getelementptr inbounds float, float* %438, i64 32
%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> %442, <4 x float> %426)
%478 = getelementptr inbounds float, float* %438, i64 36
%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> %442, <4 x float> %425)
%482 = getelementptr inbounds float, float* %438, i64 40
%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> %442, <4 x float> %424)
%486 = getelementptr inbounds float, float* %438, i64 44
%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> %442, <4 x float> %423)
%490 = getelementptr inbounds float, float* %438, i64 48
%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> %442, <4 x float> %422)
%494 = getelementptr inbounds float, float* %438, i64 52
%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> %442, <4 x float> %421)
%498 = getelementptr inbounds float, float* %438, i64 56
%499 = bitcast float* %498 to <4 x float>*
%500 = load <4 x float>, <4 x float>* %499
%501 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %500, <4 x float> %442, <4 x float> %420)
%502 = getelementptr inbounds float, float* %438, i64 60
%503 = bitcast float* %502 to <4 x float>*
%504 = load <4 x float>, <4 x float>* %503
%505 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %504, <4 x float> %442, <4 x float> %419)
%506 = getelementptr inbounds float, float* %438, i64 64
%507 = bitcast float* %506 to <4 x float>*
%508 = load <4 x float>, <4 x float>* %507
%509 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %508, <4 x float> %442, <4 x float> %418)
%510 = getelementptr inbounds float, float* %438, i64 68
%511 = bitcast float* %510 to <4 x float>*
%512 = load <4 x float>, <4 x float>* %511
%513 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %512, <4 x float> %442, <4 x float> %417)
%514 = getelementptr inbounds float, float* %438, i64 72
%515 = bitcast float* %514 to <4 x float>*
%516 = load <4 x float>, <4 x float>* %515
%517 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %516, <4 x float> %442, <4 x float> %416)
%518 = getelementptr inbounds float, float* %438, i64 76
%519 = bitcast float* %518 to <4 x float>*
%520 = load <4 x float>, <4 x float>* %519
%521 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %520, <4 x float> %442, <4 x float> %415)
%522 = icmp eq i64 %436, %245
br i1 %522, label %523, label %414
523: ; preds = %414
store <4 x float> %445, <4 x float>* %246
store <4 x float> %449, <4 x float>* %248
store <4 x float> %453, <4 x float>* %250
store <4 x float> %457, <4 x float>* %252
store <4 x float> %461, <4 x float>* %254
store <4 x float> %465, <4 x float>* %256
store <4 x float> %469, <4 x float>* %258
store <4 x float> %473, <4 x float>* %260
store <4 x float> %477, <4 x float>* %262
store <4 x float> %481, <4 x float>* %264
store <4 x float> %485, <4 x float>* %266
store <4 x float> %489, <4 x float>* %268
store <4 x float> %493, <4 x float>* %270
store <4 x float> %497, <4 x float>* %272
store <4 x float> %501, <4 x float>* %274
store <4 x float> %505, <4 x float>* %276
store <4 x float> %509, <4 x float>* %278
store <4 x float> %513, <4 x float>* %280
store <4 x float> %517, <4 x float>* %282
store <4 x float> %521, <4 x float>* %284
br label %524
524: ; preds = %523, %242
%525 = mul nsw i32 %2, 80
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds float, float* %1, i64 %526
br label %528
528: ; preds = %528, %524
%529 = phi i64 [ 0, %524 ], [ %551, %528 ]
%530 = phi float [ 0.000000e+00, %524 ], [ %544, %528 ]
%531 = phi <2 x float> [ zeroinitializer, %524 ], [ %550, %528 ]
%532 = getelementptr inbounds float, float* %527, i64 %529
%533 = load float, float* %532
%534 = tail call float @llvm.fmuladd.f32(float %533, float %533, float %530)
%535 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %529
%536 = load float, float* %535
%537 = insertelement <2 x float> poison, float %536, i64 0
%538 = shufflevector <2 x float> %537, <2 x float> poison, <2 x i32> zeroinitializer
%539 = insertelement <2 x float> %537, float %533, i64 1
%540 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %538, <2 x float> %539, <2 x float> %531)
%541 = or i64 %529, 1
%542 = getelementptr inbounds float, float* %527, i64 %541
%543 = load float, float* %542
%544 = tail call float @llvm.fmuladd.f32(float %543, float %543, float %534)
%545 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %541
%546 = load float, float* %545
%547 = insertelement <2 x float> poison, float %546, i64 0
%548 = shufflevector <2 x float> %547, <2 x float> poison, <2 x i32> zeroinitializer
%549 = insertelement <2 x float> %547, float %543, i64 1
%550 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %548, <2 x float> %549, <2 x float> %540)
%551 = add nuw nsw i64 %529, 2
%552 = icmp eq i64 %551, 80
br i1 %552, label %553, label %528
553: ; preds = %528
%554 = extractelement <2 x float> %550, i64 0
%555 = tail call float @llvm.fabs.f32(float %554)
%556 = fcmp olt float %555, 1.000000e+00
%557 = select i1 %556, float 1.000000e+00, float %554
%558 = fdiv float %544, %557
%559 = tail call float @sqrtf(float %558)
br label %560
560: ; preds = %560, %553
%561 = phi i64 [ 0, %553 ], [ %580, %560 ]
%562 = phi float [ 0.000000e+00, %553 ], [ %579, %560 ]
%563 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %561
%564 = load float, float* %563
%565 = fmul float %559, %564
%566 = getelementptr inbounds float, float* %0, i64 %561
store float %565, float* %566
%567 = getelementptr inbounds float, float* %527, i64 %561
%568 = load float, float* %567
%569 = fsub float %568, %565
%570 = tail call float @llvm.fmuladd.f32(float %569, float %569, float %562)
%571 = or i64 %561, 1
%572 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %571
%573 = load float, float* %572
%574 = fmul float %559, %573
%575 = getelementptr inbounds float, float* %0, i64 %571
store float %574, float* %575
%576 = getelementptr inbounds float, float* %527, i64 %571
%577 = load float, float* %576
%578 = fsub float %577, %574
%579 = tail call float @llvm.fmuladd.f32(float %578, float %578, float %570)
%580 = add nuw nsw i64 %561, 2
%581 = icmp eq i64 %580, 80
br i1 %581, label %582, label %560
582: ; preds = %560
%583 = fmul float %544, %3
%584 = fcmp ogt float %579, %583
br i1 %584, label %585, label %836
585: ; preds = %582
%586 = fcmp olt float %544, 1.000000e+00
%587 = select i1 %586, float 1.000000e+00, float %544
%588 = extractelement <2 x float> %550, i64 1
%589 = fneg float %588
%590 = fmul float %588, %589
%591 = tail call float @llvm.fmuladd.f32(float %557, float %587, float %590)
%592 = fmul float %587, %587
%593 = fdiv float %591, %592
%594 = fcmp ogt float %593, 0x3F1A36E2E0000000
br i1 %594, label %595, label %606
595: ; preds = %585
%596 = fmul float %3, %3
%597 = fmul float %596, 2.500000e-01
%598 = fsub float %3, %597
%599 = fdiv float %598, %593
%600 = tail call float @sqrtf(float %599)
%601 = fmul float %3, -5.000000e-01
%602 = fmul float %588, %600
%603 = fdiv float %602, %587
%604 = fsub float %601, %603
%605 = fadd float %604, 1.000000e+00
br label %606
606: ; preds = %595, %585
%607 = phi float [ %600, %595 ], [ 0.000000e+00, %585 ]
%608 = phi float [ %605, %595 ], [ 1.000000e+00, %585 ]
%609 = getelementptr float, float* %0, i64 80
%610 = add nsw i64 %526, 80
%611 = getelementptr float, float* %1, i64 %610
%612 = icmp ugt float* %611, %0
%613 = icmp ult float* %527, %609
%614 = and i1 %612, %613
br i1 %614, label %817, label %615
615: ; preds = %606
%616 = insertelement <4 x float> poison, float %608, i64 0
%617 = shufflevector <4 x float> %616, <4 x float> poison, <4 x i32> zeroinitializer
%618 = insertelement <4 x float> poison, float %607, i64 0
%619 = shufflevector <4 x float> %618, <4 x float> poison, <4 x i32> zeroinitializer
%620 = bitcast [240 x float]* %5 to <4 x float>*
%621 = load <4 x float>, <4 x float>* %620
%622 = bitcast float* %527 to <4 x float>*
%623 = load <4 x float>, <4 x float>* %622
%624 = fmul <4 x float> %617, %623
%625 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %621, <4 x float> %624)
%626 = bitcast float* %0 to <4 x float>*
store <4 x float> %625, <4 x float>* %626
%627 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 4
%628 = bitcast float* %627 to <4 x float>*
%629 = load <4 x float>, <4 x float>* %628
%630 = getelementptr inbounds float, float* %527, i64 4
%631 = bitcast float* %630 to <4 x float>*
%632 = load <4 x float>, <4 x float>* %631
%633 = fmul <4 x float> %617, %632
%634 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %629, <4 x float> %633)
%635 = getelementptr inbounds float, float* %0, i64 4
%636 = bitcast float* %635 to <4 x float>*
store <4 x float> %634, <4 x float>* %636
%637 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 8
%638 = bitcast float* %637 to <4 x float>*
%639 = load <4 x float>, <4 x float>* %638
%640 = getelementptr inbounds float, float* %527, i64 8
%641 = bitcast float* %640 to <4 x float>*
%642 = load <4 x float>, <4 x float>* %641
%643 = fmul <4 x float> %617, %642
%644 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %639, <4 x float> %643)
%645 = getelementptr inbounds float, float* %0, i64 8
%646 = bitcast float* %645 to <4 x float>*
store <4 x float> %644, <4 x float>* %646
%647 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 12
%648 = bitcast float* %647 to <4 x float>*
%649 = load <4 x float>, <4 x float>* %648
%650 = getelementptr inbounds float, float* %527, i64 12
%651 = bitcast float* %650 to <4 x float>*
%652 = load <4 x float>, <4 x float>* %651
%653 = fmul <4 x float> %617, %652
%654 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %649, <4 x float> %653)
%655 = getelementptr inbounds float, float* %0, i64 12
%656 = bitcast float* %655 to <4 x float>*
store <4 x float> %654, <4 x float>* %656
%657 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 16
%658 = bitcast float* %657 to <4 x float>*
%659 = load <4 x float>, <4 x float>* %658
%660 = getelementptr inbounds float, float* %527, i64 16
%661 = bitcast float* %660 to <4 x float>*
%662 = load <4 x float>, <4 x float>* %661
%663 = fmul <4 x float> %617, %662
%664 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %659, <4 x float> %663)
%665 = getelementptr inbounds float, float* %0, i64 16
%666 = bitcast float* %665 to <4 x float>*
store <4 x float> %664, <4 x float>* %666
%667 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 20
%668 = bitcast float* %667 to <4 x float>*
%669 = load <4 x float>, <4 x float>* %668
%670 = getelementptr inbounds float, float* %527, i64 20
%671 = bitcast float* %670 to <4 x float>*
%672 = load <4 x float>, <4 x float>* %671
%673 = fmul <4 x float> %617, %672
%674 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %669, <4 x float> %673)
%675 = getelementptr inbounds float, float* %0, i64 20
%676 = bitcast float* %675 to <4 x float>*
store <4 x float> %674, <4 x float>* %676
%677 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 24
%678 = bitcast float* %677 to <4 x float>*
%679 = load <4 x float>, <4 x float>* %678
%680 = getelementptr inbounds float, float* %527, i64 24
%681 = bitcast float* %680 to <4 x float>*
%682 = load <4 x float>, <4 x float>* %681
%683 = fmul <4 x float> %617, %682
%684 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %679, <4 x float> %683)
%685 = getelementptr inbounds float, float* %0, i64 24
%686 = bitcast float* %685 to <4 x float>*
store <4 x float> %684, <4 x float>* %686
%687 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 28
%688 = bitcast float* %687 to <4 x float>*
%689 = load <4 x float>, <4 x float>* %688
%690 = getelementptr inbounds float, float* %527, i64 28
%691 = bitcast float* %690 to <4 x float>*
%692 = load <4 x float>, <4 x float>* %691
%693 = fmul <4 x float> %617, %692
%694 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %689, <4 x float> %693)
%695 = getelementptr inbounds float, float* %0, i64 28
%696 = bitcast float* %695 to <4 x float>*
store <4 x float> %694, <4 x float>* %696
%697 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 32
%698 = bitcast float* %697 to <4 x float>*
%699 = load <4 x float>, <4 x float>* %698
%700 = getelementptr inbounds float, float* %527, i64 32
%701 = bitcast float* %700 to <4 x float>*
%702 = load <4 x float>, <4 x float>* %701
%703 = fmul <4 x float> %617, %702
%704 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %699, <4 x float> %703)
%705 = getelementptr inbounds float, float* %0, i64 32
%706 = bitcast float* %705 to <4 x float>*
store <4 x float> %704, <4 x float>* %706
%707 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 36
%708 = bitcast float* %707 to <4 x float>*
%709 = load <4 x float>, <4 x float>* %708
%710 = getelementptr inbounds float, float* %527, i64 36
%711 = bitcast float* %710 to <4 x float>*
%712 = load <4 x float>, <4 x float>* %711
%713 = fmul <4 x float> %617, %712
%714 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %709, <4 x float> %713)
%715 = getelementptr inbounds float, float* %0, i64 36
%716 = bitcast float* %715 to <4 x float>*
store <4 x float> %714, <4 x float>* %716
%717 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 40
%718 = bitcast float* %717 to <4 x float>*
%719 = load <4 x float>, <4 x float>* %718
%720 = getelementptr inbounds float, float* %527, i64 40
%721 = bitcast float* %720 to <4 x float>*
%722 = load <4 x float>, <4 x float>* %721
%723 = fmul <4 x float> %617, %722
%724 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %719, <4 x float> %723)
%725 = getelementptr inbounds float, float* %0, i64 40
%726 = bitcast float* %725 to <4 x float>*
store <4 x float> %724, <4 x float>* %726
%727 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 44
%728 = bitcast float* %727 to <4 x float>*
%729 = load <4 x float>, <4 x float>* %728
%730 = getelementptr inbounds float, float* %527, i64 44
%731 = bitcast float* %730 to <4 x float>*
%732 = load <4 x float>, <4 x float>* %731
%733 = fmul <4 x float> %617, %732
%734 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %729, <4 x float> %733)
%735 = getelementptr inbounds float, float* %0, i64 44
%736 = bitcast float* %735 to <4 x float>*
store <4 x float> %734, <4 x float>* %736
%737 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 48
%738 = bitcast float* %737 to <4 x float>*
%739 = load <4 x float>, <4 x float>* %738
%740 = getelementptr inbounds float, float* %527, i64 48
%741 = bitcast float* %740 to <4 x float>*
%742 = load <4 x float>, <4 x float>* %741
%743 = fmul <4 x float> %617, %742
%744 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %739, <4 x float> %743)
%745 = getelementptr inbounds float, float* %0, i64 48
%746 = bitcast float* %745 to <4 x float>*
store <4 x float> %744, <4 x float>* %746
%747 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 52
%748 = bitcast float* %747 to <4 x float>*
%749 = load <4 x float>, <4 x float>* %748
%750 = getelementptr inbounds float, float* %527, i64 52
%751 = bitcast float* %750 to <4 x float>*
%752 = load <4 x float>, <4 x float>* %751
%753 = fmul <4 x float> %617, %752
%754 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %749, <4 x float> %753)
%755 = getelementptr inbounds float, float* %0, i64 52
%756 = bitcast float* %755 to <4 x float>*
store <4 x float> %754, <4 x float>* %756
%757 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 56
%758 = bitcast float* %757 to <4 x float>*
%759 = load <4 x float>, <4 x float>* %758
%760 = getelementptr inbounds float, float* %527, i64 56
%761 = bitcast float* %760 to <4 x float>*
%762 = load <4 x float>, <4 x float>* %761
%763 = fmul <4 x float> %617, %762
%764 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %759, <4 x float> %763)
%765 = getelementptr inbounds float, float* %0, i64 56
%766 = bitcast float* %765 to <4 x float>*
store <4 x float> %764, <4 x float>* %766
%767 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 60
%768 = bitcast float* %767 to <4 x float>*
%769 = load <4 x float>, <4 x float>* %768
%770 = getelementptr inbounds float, float* %527, i64 60
%771 = bitcast float* %770 to <4 x float>*
%772 = load <4 x float>, <4 x float>* %771
%773 = fmul <4 x float> %617, %772
%774 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %769, <4 x float> %773)
%775 = getelementptr inbounds float, float* %0, i64 60
%776 = bitcast float* %775 to <4 x float>*
store <4 x float> %774, <4 x float>* %776
%777 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 64
%778 = bitcast float* %777 to <4 x float>*
%779 = load <4 x float>, <4 x float>* %778
%780 = getelementptr inbounds float, float* %527, i64 64
%781 = bitcast float* %780 to <4 x float>*
%782 = load <4 x float>, <4 x float>* %781
%783 = fmul <4 x float> %617, %782
%784 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %779, <4 x float> %783)
%785 = getelementptr inbounds float, float* %0, i64 64
%786 = bitcast float* %785 to <4 x float>*
store <4 x float> %784, <4 x float>* %786
%787 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 68
%788 = bitcast float* %787 to <4 x float>*
%789 = load <4 x float>, <4 x float>* %788
%790 = getelementptr inbounds float, float* %527, i64 68
%791 = bitcast float* %790 to <4 x float>*
%792 = load <4 x float>, <4 x float>* %791
%793 = fmul <4 x float> %617, %792
%794 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %789, <4 x float> %793)
%795 = getelementptr inbounds float, float* %0, i64 68
%796 = bitcast float* %795 to <4 x float>*
store <4 x float> %794, <4 x float>* %796
%797 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 72
%798 = bitcast float* %797 to <4 x float>*
%799 = load <4 x float>, <4 x float>* %798
%800 = getelementptr inbounds float, float* %527, i64 72
%801 = bitcast float* %800 to <4 x float>*
%802 = load <4 x float>, <4 x float>* %801
%803 = fmul <4 x float> %617, %802
%804 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %799, <4 x float> %803)
%805 = getelementptr inbounds float, float* %0, i64 72
%806 = bitcast float* %805 to <4 x float>*
store <4 x float> %804, <4 x float>* %806
%807 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 76
%808 = bitcast float* %807 to <4 x float>*
%809 = load <4 x float>, <4 x float>* %808
%810 = getelementptr inbounds float, float* %527, i64 76
%811 = bitcast float* %810 to <4 x float>*
%812 = load <4 x float>, <4 x float>* %811
%813 = fmul <4 x float> %617, %812
%814 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %619, <4 x float> %809, <4 x float> %813)
%815 = getelementptr inbounds float, float* %0, i64 76
%816 = bitcast float* %815 to <4 x float>*
store <4 x float> %814, <4 x float>* %816
br label %836
817: ; preds = %606, %817
%818 = phi i64 [ %834, %817 ], [ 0, %606 ]
%819 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %818
%820 = load float, float* %819
%821 = getelementptr inbounds float, float* %527, i64 %818
%822 = load float, float* %821
%823 = fmul float %608, %822
%824 = tail call float @llvm.fmuladd.f32(float %607, float %820, float %823)
%825 = getelementptr inbounds float, float* %0, i64 %818
store float %824, float* %825
%826 = or i64 %818, 1
%827 = getelementptr inbounds [240 x float], [240 x float]* %5, i64 0, i64 %826
%828 = load float, float* %827
%829 = getelementptr inbounds float, float* %527, i64 %826
%830 = load float, float* %829
%831 = fmul float %608, %830
%832 = tail call float @llvm.fmuladd.f32(float %607, float %828, float %831)
%833 = getelementptr inbounds float, float* %0, i64 %826
store float %832, float* %833
%834 = add nuw nsw i64 %818, 2
%835 = icmp eq i64 %834, 80
br i1 %835, label %836, label %817
836: ; preds = %817, %615, %582
ret void
}