#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 HUGE_VALF;
scalar_t__ M_SQRT2;
scalar_t__ isfinite(float);
scalar_t__ isnan(float);
float smff2w_2(float);
void smf4lowres(float *u, int n, float *y, float *x, float *f, float *r) {
  int i;
  float t1, t2, t3, t4, t5, t6, t7, u1, u2, u3, u4, w_2, _r;
  u1 = u[0];
  u2 = u[1];
  u3 = u[2];
  u4 = u[3];
  for (i = 0; i < n; i++) {
    w_2 = smff2w_2(f[i]);
    _r = ((float)M_SQRT2) * r[i];
    t1 = ((1 + 1.847759065022574f * w_2 + w_2 * w_2) *
              (1 + 0.7653668647301796f * w_2 + w_2 * w_2) * x[i] -
          (w_2 * w_2 * u1 + (1.0f + 1.847759065022574f * w_2) * w_2 * w_2 * u2 +
           (1.0f + 1.847759065022574f * w_2 + w_2 * w_2) * w_2 * u3 +
           (1.0f + 0.7653668647301796f * w_2) *
               (1.0f + 1.847759065022574f * w_2 + w_2 * w_2) * u4) *
              _r) /
         ((1.0f + 1.847759065022574f * w_2 + w_2 * w_2) *
              (1.0f + 0.7653668647301796f * w_2 + w_2 * w_2) +
          w_2 * w_2 * w_2 * w_2 * _r);
    t2 = (t1 - (w_2 + 1.847759065022574f) * u1 - u2) /
         (1.0f + 1.847759065022574f * w_2 + w_2 * w_2);
    t3 = u1 + t2 * w_2;
    t4 = u2 + t3 * w_2;
    t5 = (t4 - (w_2 + 0.7653668647301796f) * u3 - u4) /
         (1.0f + 0.7653668647301796f * w_2 + w_2 * w_2);
    t6 = u3 + w_2 * t5;
    t7 = u4 + w_2 * t6;
    u1 = w_2 * t2 + t3;
    u2 = w_2 * t3 + t4;
    u3 = w_2 * t5 + t6;
    u4 = w_2 * t6 + t7;
    u1 = (isfinite(u1) ? (u1)
          : isnan(u1)  ? 0.0f
          : u1 > 0.0f  ? HUGE_VALF
                       : -HUGE_VALF);
    u2 = (isfinite(u2) ? (u2)
          : isnan(u2)  ? 0.0f
          : u2 > 0.0f  ? HUGE_VALF
                       : -HUGE_VALF);
    u3 = (isfinite(u3) ? (u3)
          : isnan(u3)  ? 0.0f
          : u3 > 0.0f  ? HUGE_VALF
                       : -HUGE_VALF);
    u4 = (isfinite(u4) ? (u4)
          : isnan(u4)  ? 0.0f
          : u4 > 0.0f  ? HUGE_VALF
                       : -HUGE_VALF);
    y[i] = t7;
  }
  u[0] = u1;
  u[1] = u2;
  u[2] = u3;
  u[3] = u4;
}


x86 assembly (clang, -O0):
<smf4lowres>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    185f <smf4lowres+0x72f>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <smff2w_2@plt>
movss  %xmm0,-0x64(%rbp)
mov    0x2e1e(%rip),%rax
cvtsi2ssq (%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm1
movss  0xe2a(%rip),%xmm0
mulss  %xmm0,%xmm1
movss  0xe1a(%rip),%xmm0
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm2
movss  0xdf3(%rip),%xmm1
mulss  %xmm1,%xmm2
movss  0xdeb(%rip),%xmm1
addss  %xmm1,%xmm2
movss  -0x64(%rbp),%xmm1
movss  -0x64(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movss  -0x54(%rbp),%xmm4
movss  -0x64(%rbp),%xmm3
movss  0xdac(%rip),%xmm5
mulss  %xmm5,%xmm3
movss  0xd9c(%rip),%xmm5
addss  %xmm5,%xmm3
mulss  -0x64(%rbp),%xmm3
mulss  -0x64(%rbp),%xmm3
mulss  -0x58(%rbp),%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x64(%rbp),%xmm4
movss  0xd78(%rip),%xmm3
mulss  %xmm3,%xmm4
movss  0xd68(%rip),%xmm3
addss  %xmm3,%xmm4
movss  -0x64(%rbp),%xmm3
movss  -0x64(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  -0x64(%rbp),%xmm3
movss  -0x5c(%rbp),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x64(%rbp),%xmm1
movss  0xd2f(%rip),%xmm4
mulss  %xmm4,%xmm1
movss  0xd27(%rip),%xmm4
addss  %xmm4,%xmm1
movss  -0x64(%rbp),%xmm5
movss  0xd1a(%rip),%xmm4
mulss  %xmm4,%xmm5
movss  0xd0a(%rip),%xmm4
addss  %xmm4,%xmm5
movss  -0x64(%rbp),%xmm4
movss  -0x64(%rbp),%xmm6
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movss  -0x60(%rbp),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm2
movss  0xcc0(%rip),%xmm1
mulss  %xmm1,%xmm2
movss  0xcb0(%rip),%xmm1
addss  %xmm1,%xmm2
movss  -0x64(%rbp),%xmm1
movss  -0x64(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x64(%rbp),%xmm2
movss  0xc89(%rip),%xmm3
mulss  %xmm3,%xmm2
movss  0xc81(%rip),%xmm3
addss  %xmm3,%xmm2
movss  -0x64(%rbp),%xmm3
movss  -0x64(%rbp),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x64(%rbp),%xmm2
mulss  -0x64(%rbp),%xmm2
mulss  -0x64(%rbp),%xmm2
mulss  -0x64(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm1
movss  0xc38(%rip),%xmm0
addss  -0x64(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x58(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  0xc07(%rip),%xmm1
mulss  %xmm1,%xmm2
movss  0xbf7(%rip),%xmm1
addss  %xmm1,%xmm2
movss  -0x64(%rbp),%xmm1
movss  -0x64(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm1
movss  0xb8f(%rip),%xmm0
addss  -0x64(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x60(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  0xb5e(%rip),%xmm1
mulss  %xmm1,%xmm2
movss  0xb56(%rip),%xmm1
addss  %xmm1,%xmm2
movss  -0x64(%rbp),%xmm1
movss  -0x64(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
call   1030 <isfinite@plt>
cmp    $0x0,%rax
je     1598 <smf4lowres+0x468>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    1610 <smf4lowres+0x4e0>
movss  -0x54(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     15b9 <smf4lowres+0x489>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
jmp    1606 <smf4lowres+0x4d6>
movss  -0x54(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    15df <smf4lowres+0x4af>
mov    0x2a1f(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    15fc <smf4lowres+0x4cc>
mov    0x2a0a(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
call   1030 <isfinite@plt>
cmp    $0x0,%rax
je     163d <smf4lowres+0x50d>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    16b5 <smf4lowres+0x585>
movss  -0x58(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     165e <smf4lowres+0x52e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    16ab <smf4lowres+0x57b>
movss  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1684 <smf4lowres+0x554>
mov    0x297a(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
jmp    16a1 <smf4lowres+0x571>
mov    0x2965(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
call   1030 <isfinite@plt>
cmp    $0x0,%rax
je     16e5 <smf4lowres+0x5b5>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    1772 <smf4lowres+0x642>
movss  -0x5c(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     1709 <smf4lowres+0x5d9>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
jmp    1762 <smf4lowres+0x632>
movss  -0x5c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1732 <smf4lowres+0x602>
mov    0x28cf(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
jmp    1752 <smf4lowres+0x622>
mov    0x28b7(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x5c(%rbp)
movss  -0x60(%rbp),%xmm0
call   1030 <isfinite@plt>
cmp    $0x0,%rax
je     17a5 <smf4lowres+0x675>
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
jmp    1832 <smf4lowres+0x702>
movss  -0x60(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     17c9 <smf4lowres+0x699>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
jmp    1822 <smf4lowres+0x6f2>
movss  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    17f2 <smf4lowres+0x6c2>
mov    0x280f(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1812 <smf4lowres+0x6e2>
mov    0x27f7(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x60(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1190 <smf4lowres+0x60>
movss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<smf4lowres>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
movss  (%rdi),%xmm0
movaps %xmm0,0x40(%rsp)
movss  0x4(%rdi),%xmm4
movss  0x8(%rdi),%xmm5
mov    %rdi,0x58(%rsp)
movss  0xc(%rdi),%xmm1
test   %esi,%esi
jle    152d <smf4lowres+0x3fd>
mov    %r9,%r15
mov    %r8,%r12
mov    %rcx,%r13
mov    %rdx,%rbx
mov    %esi,%ebp
xor    %r14d,%r14d
jmp    11ab <smf4lowres+0x7b>
nopl   0x0(%rax)
movaps 0x20(%rsp),%xmm0
movss  0x8(%rsp),%xmm3
movaps 0x30(%rsp),%xmm4
movaps 0x10(%rsp),%xmm5
movss  %xmm3,(%rbx,%r14,4)
add    $0x1,%r14
movaps %xmm0,%xmm1
cmp    %r14,%rbp
je     1530 <smf4lowres+0x400>
movss  %xmm1,0x8(%rsp)
movss  %xmm4,0x10(%rsp)
movss  %xmm5,0xc(%rsp)
movss  (%r12,%r14,4),%xmm0
call   1050 <smff2w_2@plt>
mov    0x2e09(%rip),%rax
xorps  %xmm1,%xmm1
cvtsi2ssq (%rax),%xmm1
mulss  (%r15,%r14,4),%xmm1
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
mulps  0xe15(%rip),%xmm2
addps  0xe1e(%rip),%xmm2
movaps %xmm0,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm3,%xmm7
shufps $0x0,%xmm3,%xmm7
addps  %xmm2,%xmm7
movaps %xmm0,%xmm4
mulss  %xmm2,%xmm4
mulss  %xmm0,%xmm4
movss  0x10(%rsp),%xmm8
mulss  %xmm8,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm3,%xmm5
movaps 0x40(%rsp),%xmm9
mulss  %xmm9,%xmm3
addss  %xmm4,%xmm3
movaps %xmm0,%xmm4
mulss  %xmm7,%xmm4
mulss  0xc(%rsp),%xmm4
addss  %xmm3,%xmm4
shufps $0x55,%xmm2,%xmm2
mulss  %xmm7,%xmm2
mulss  0x8(%rsp),%xmm2
addss  %xmm4,%xmm2
movaps %xmm7,%xmm3
shufps $0x55,%xmm7,%xmm3
xorps  0xdbf(%rip),%xmm2
mulss  %xmm0,%xmm5
unpcklps %xmm5,%xmm2
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
movss  0x0(%r13,%r14,4),%xmm2
movaps %xmm7,%xmm4
movss  %xmm2,%xmm4
movaps %xmm7,%xmm2
movaps %xmm3,0x70(%rsp)
mulss  %xmm3,%xmm2
unpcklps %xmm7,%xmm2
mulps  %xmm2,%xmm4
addps  %xmm1,%xmm4
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
divss  %xmm1,%xmm4
movaps %xmm0,%xmm1
addss  0xd88(%rip),%xmm1
mulss  %xmm9,%xmm1
subss  %xmm1,%xmm4
subss  %xmm8,%xmm4
divss  %xmm7,%xmm4
mulss  %xmm0,%xmm4
movaps %xmm9,%xmm6
addss  %xmm4,%xmm6
movaps %xmm0,0x20(%rsp)
addss  0xd61(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movss  %xmm6,0x30(%rsp)
addss  %xmm6,%xmm4
movaps %xmm4,0x40(%rsp)
movaps %xmm4,%xmm0
call   1030 <isfinite@plt>
test   %rax,%rax
je     1310 <smf4lowres+0x1e0>
movaps 0x40(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
movss  0x10(%rsp),%xmm4
movss  0x30(%rsp),%xmm0
jmp    1360 <smf4lowres+0x230>
nopl   0x0(%rax)
movaps 0x40(%rsp),%xmm0
call   1040 <isnan@plt>
xorps  %xmm2,%xmm2
test   %rax,%rax
movaps 0x20(%rsp),%xmm3
movss  0x10(%rsp),%xmm4
movss  0x30(%rsp),%xmm0
jne    1360 <smf4lowres+0x230>
mov    0x2cb6(%rip),%rax
movss  (%rax),%xmm5
xorps  %xmm2,%xmm2
cmpltss 0x40(%rsp),%xmm2
movaps %xmm2,%xmm1
andps  %xmm5,%xmm1
xorps  0xccb(%rip),%xmm5
andnps %xmm5,%xmm2
orps   %xmm1,%xmm2
nopl   0x0(%rax,%rax,1)
movaps %xmm2,0x40(%rsp)
mulss  %xmm3,%xmm0
addss  %xmm0,%xmm4
movss  %xmm4,0x10(%rsp)
addss  %xmm4,%xmm0
movss  %xmm0,0x30(%rsp)
call   1030 <isfinite@plt>
test   %rax,%rax
je     13b0 <smf4lowres+0x280>
movss  0x30(%rsp),%xmm6
movss  0x8(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
movss  0xc(%rsp),%xmm4
movss  0x10(%rsp),%xmm0
movaps 0x70(%rsp),%xmm7
movaps 0x60(%rsp),%xmm1
jmp    1410 <smf4lowres+0x2e0>
movss  0x30(%rsp),%xmm0
call   1040 <isnan@plt>
xorps  %xmm6,%xmm6
test   %rax,%rax
movss  0x8(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
movss  0xc(%rsp),%xmm4
movss  0x10(%rsp),%xmm0
movaps 0x70(%rsp),%xmm7
movaps 0x60(%rsp),%xmm1
jne    1410 <smf4lowres+0x2e0>
mov    0x2c05(%rip),%rax
movss  (%rax),%xmm5
xorps  %xmm6,%xmm6
cmpltss 0x30(%rsp),%xmm6
movaps %xmm6,%xmm8
andps  %xmm5,%xmm8
xorps  0xc18(%rip),%xmm5
andnps %xmm5,%xmm6
orps   %xmm8,%xmm6
nop
movaps %xmm6,0x30(%rsp)
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm0
subss  %xmm2,%xmm0
divss  %xmm7,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm0,%xmm4
movss  %xmm4,0xc(%rsp)
addss  %xmm4,%xmm0
movss  %xmm0,0x10(%rsp)
call   1030 <isfinite@plt>
test   %rax,%rax
je     1460 <smf4lowres+0x330>
movss  0x10(%rsp),%xmm5
movss  0x8(%rsp),%xmm2
movaps 0x20(%rsp),%xmm0
movss  0xc(%rsp),%xmm4
jmp    14b0 <smf4lowres+0x380>
movss  0x10(%rsp),%xmm0
call   1040 <isnan@plt>
xorps  %xmm5,%xmm5
test   %rax,%rax
movss  0x8(%rsp),%xmm2
movaps 0x20(%rsp),%xmm0
movss  0xc(%rsp),%xmm4
jne    14b0 <smf4lowres+0x380>
mov    0x2b65(%rip),%rax
movss  (%rax),%xmm3
xorps  %xmm5,%xmm5
cmpltss 0x10(%rsp),%xmm5
movaps %xmm5,%xmm1
andps  %xmm3,%xmm1
xorps  0xb7a(%rip),%xmm3
andnps %xmm3,%xmm5
orps   %xmm1,%xmm5
nopl   0x0(%rax)
movaps %xmm5,0x10(%rsp)
mulss  %xmm4,%xmm0
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rsp)
addss  %xmm2,%xmm0
movaps %xmm0,0x20(%rsp)
call   1030 <isfinite@plt>
test   %rax,%rax
jne    1180 <smf4lowres+0x50>
movaps 0x20(%rsp),%xmm0
call   1040 <isnan@plt>
xorps  %xmm0,%xmm0
test   %rax,%rax
movss  0x8(%rsp),%xmm3
movaps 0x30(%rsp),%xmm4
movaps 0x10(%rsp),%xmm5
jne    1195 <smf4lowres+0x65>
mov    0x2ae9(%rip),%rax
movss  (%rax),%xmm1
xorps  %xmm0,%xmm0
cmpltss 0x20(%rsp),%xmm0
movaps %xmm0,%xmm2
andps  %xmm1,%xmm2
xorps  0xafe(%rip),%xmm1
andnps %xmm1,%xmm0
orps   %xmm2,%xmm0
jmp    1195 <smf4lowres+0x65>
movaps %xmm1,%xmm0
mov    0x58(%rsp),%rax
movaps 0x40(%rsp),%xmm1
movss  %xmm1,(%rax)
movss  %xmm4,0x4(%rax)
movss  %xmm5,0x8(%rax)
movss  %xmm0,0xc(%rax)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@M_SQRT2 = global i64 0
@HUGE_VALF = global float 0.000000e+00
define void @smf4lowres(float* nocapture %0, i32 %1, float* nocapture writeonly %2, float* nocapture %3, float* nocapture %4, float* nocapture %5) {
%7 = load float, float* %0
%8 = getelementptr inbounds float, float* %0, i64 1
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %0, i64 2
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %0, i64 3
%13 = load float, float* %12
%14 = icmp sgt i32 %1, 0
br i1 %14, label %15, label %136
15: ; preds = %6
%16 = zext i32 %1 to i64
br label %17
17: ; preds = %15, %131
%18 = phi i64 [ 0, %15 ], [ %134, %131 ]
%19 = phi float [ %7, %15 ], [ %96, %131 ]
%20 = phi float [ %13, %15 ], [ %132, %131 ]
%21 = phi float [ %11, %15 ], [ %120, %131 ]
%22 = phi float [ %9, %15 ], [ %108, %131 ]
%23 = getelementptr inbounds float, float* %4, i64 %18
%24 = load float, float* %23
%25 = tail call float @smff2w_2(float %24)
%26 = load i64, i64* @M_SQRT2
%27 = sitofp i64 %26 to float
%28 = getelementptr inbounds float, float* %5, i64 %18
%29 = load float, float* %28
%30 = fmul float %29, %27
%31 = insertelement <2 x float> poison, float %25, i64 0
%32 = shufflevector <2 x float> %31, <2 x float> poison, <2 x i32> zeroinitializer
%33 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %32, <2 x float> <float 0x3FFD906BC0000000, float 0x3FE87DE2A0000000>, <2 x float> <float 1.000000e+00, float 1.000000e+00>)
%34 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %32, <2 x float> %32, <2 x float> %33)
%35 = extractelement <2 x float> %34, i64 0
%36 = extractelement <2 x float> %34, i64 1
%37 = fmul float %35, %36
%38 = getelementptr inbounds float, float* %3, i64 %18
%39 = load float, float* %38
%40 = fmul float %25, %25
%41 = extractelement <2 x float> %33, i64 0
%42 = fmul float %25, %41
%43 = fmul float %25, %42
%44 = fmul float %22, %43
%45 = tail call float @llvm.fmuladd.f32(float %40, float %19, float %44)
%46 = fmul float %25, %35
%47 = tail call float @llvm.fmuladd.f32(float %46, float %21, float %45)
%48 = shufflevector <2 x float> %33, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%49 = fmul <2 x float> %48, %34
%50 = extractelement <2 x float> %49, i64 0
%51 = tail call float @llvm.fmuladd.f32(float %50, float %20, float %47)
%52 = fneg float %51
%53 = fmul float %25, %40
%54 = fmul float %25, %53
%55 = insertelement <2 x float> poison, float %30, i64 0
%56 = shufflevector <2 x float> %55, <2 x float> poison, <2 x i32> zeroinitializer
%57 = insertelement <2 x float> poison, float %52, i64 0
%58 = insertelement <2 x float> %57, float %54, i64 1
%59 = fmul <2 x float> %56, %58
%60 = insertelement <2 x float> poison, float %37, i64 0
%61 = shufflevector <2 x float> %60, <2 x float> %34, <2 x i32> <i32 0, i32 2>
%62 = insertelement <2 x float> %34, float %39, i64 0
%63 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %61, <2 x float> %62, <2 x float> %59)
%64 = extractelement <2 x float> %63, i64 0
%65 = extractelement <2 x float> %63, i64 1
%66 = fdiv float %64, %65
%67 = fadd float %25, 0x3FFD906BC0000000
%68 = fneg float %67
%69 = tail call float @llvm.fmuladd.f32(float %68, float %19, float %66)
%70 = fsub float %69, %22
%71 = fdiv float %70, %35
%72 = tail call float @llvm.fmuladd.f32(float %71, float %25, float %19)
%73 = tail call float @llvm.fmuladd.f32(float %72, float %25, float %22)
%74 = fadd float %25, 0x3FE87DE2A0000000
%75 = fneg float %74
%76 = tail call float @llvm.fmuladd.f32(float %75, float %21, float %73)
%77 = fsub float %76, %20
%78 = fdiv float %77, %36
%79 = tail call float @llvm.fmuladd.f32(float %25, float %78, float %21)
%80 = tail call float @llvm.fmuladd.f32(float %25, float %79, float %20)
%81 = tail call float @llvm.fmuladd.f32(float %25, float %71, float %72)
%82 = tail call float @llvm.fmuladd.f32(float %25, float %72, float %73)
%83 = tail call float @llvm.fmuladd.f32(float %25, float %78, float %79)
%84 = tail call float @llvm.fmuladd.f32(float %25, float %79, float %80)
%85 = tail call i64 @isfinite(float %81)
%86 = icmp eq i64 %85, 0
br i1 %86, label %87, label %95
87: ; preds = %17
%88 = tail call i64 @isnan(float %81)
%89 = icmp eq i64 %88, 0
br i1 %89, label %90, label %95
90: ; preds = %87
%91 = fcmp ogt float %81, 0.000000e+00
%92 = load float, float* @HUGE_VALF
%93 = fneg float %92
%94 = select i1 %91, float %92, float %93
br label %95
95: ; preds = %17, %90, %87
%96 = phi float [ %94, %90 ], [ 0.000000e+00, %87 ], [ %81, %17 ]
%97 = tail call i64 @isfinite(float %82)
%98 = icmp eq i64 %97, 0
br i1 %98, label %99, label %107
99: ; preds = %95
%100 = tail call i64 @isnan(float %82)
%101 = icmp eq i64 %100, 0
br i1 %101, label %102, label %107
102: ; preds = %99
%103 = fcmp ogt float %82, 0.000000e+00
%104 = load float, float* @HUGE_VALF
%105 = fneg float %104
%106 = select i1 %103, float %104, float %105
br label %107
107: ; preds = %95, %102, %99
%108 = phi float [ %106, %102 ], [ 0.000000e+00, %99 ], [ %82, %95 ]
%109 = tail call i64 @isfinite(float %83)
%110 = icmp eq i64 %109, 0
br i1 %110, label %111, label %119
111: ; preds = %107
%112 = tail call i64 @isnan(float %83)
%113 = icmp eq i64 %112, 0
br i1 %113, label %114, label %119
114: ; preds = %111
%115 = fcmp ogt float %83, 0.000000e+00
%116 = load float, float* @HUGE_VALF
%117 = fneg float %116
%118 = select i1 %115, float %116, float %117
br label %119
119: ; preds = %107, %114, %111
%120 = phi float [ %118, %114 ], [ 0.000000e+00, %111 ], [ %83, %107 ]
%121 = tail call i64 @isfinite(float %84)
%122 = icmp eq i64 %121, 0
br i1 %122, label %123, label %131
123: ; preds = %119
%124 = tail call i64 @isnan(float %84)
%125 = icmp eq i64 %124, 0
br i1 %125, label %126, label %131
126: ; preds = %123
%127 = fcmp ogt float %84, 0.000000e+00
%128 = load float, float* @HUGE_VALF
%129 = fneg float %128
%130 = select i1 %127, float %128, float %129
br label %131
131: ; preds = %119, %126, %123
%132 = phi float [ %130, %126 ], [ 0.000000e+00, %123 ], [ %84, %119 ]
%133 = getelementptr inbounds float, float* %2, i64 %18
store float %80, float* %133
%134 = add nuw nsw i64 %18, 1
%135 = icmp eq i64 %134, %16
br i1 %135, label %136, label %17
136: ; preds = %131, %6
%137 = phi float [ %9, %6 ], [ %108, %131 ]
%138 = phi float [ %11, %6 ], [ %120, %131 ]
%139 = phi float [ %13, %6 ], [ %132, %131 ]
%140 = phi float [ %7, %6 ], [ %96, %131 ]
store float %140, float* %0
store float %137, float* %8
store float %138, float* %10
store float %139, float* %12
ret void
}