#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__ isfinite(float);
scalar_t__ isnan(float);
float smff2w_2(float);
void smf3lowres(float *u, int n, float *y, float *x, float *f, float *r) {
  int i;
  float t1, t2, t3, t4, t5, t6, u1, u2, u3, w_2, _r;
  u1 = u[0];
  u2 = u[1];
  u3 = u[2];
  for (i = 0; i < n; i++) {
    w_2 = smff2w_2(f[i]);
    _r = 3.0f * r[i];
    t1 =
        ((1.0f + w_2) * (1.0f + 1.0f * w_2 + w_2 * w_2) * x[i] -
         (w_2 * w_2 * u1 + (1.0f + w_2) * w_2 * u2 +
          (1.0f + w_2) * (1.0f + 1.0f * w_2) * u3) *
             _r) /
        ((1.0f + w_2) * (1.0f + 1.0f * w_2 + w_2 * w_2) + w_2 * w_2 * w_2 * _r);
    t2 = (t1 - u1) / (1.0f + w_2);
    t3 = u1 + w_2 * t2;
    t4 = (t3 - (w_2 + 1.0f) * u2 - u3) / (1.0f + 1.0f * w_2 + w_2 * w_2);
    t5 = u2 + w_2 * t4;
    t6 = u3 + w_2 * t5;
    u1 = w_2 * t2 + t3;
    u2 = w_2 * t4 + t5;
    u3 = w_2 * t5 + t6;
    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);
    y[i] = t6;
  }
  u[0] = u1;
  u[1] = u2;
  u[2] = u3;
}


x86 assembly (clang, -O0):
<smf3lowres>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1609 <smf3lowres+0x4d9>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <smff2w_2@plt>
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  0xe4f(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  0xe39(%rip),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  0xe27(%rip),%xmm1
addss  %xmm1,%xmm2
movss  -0x5c(%rbp),%xmm1
movss  -0x5c(%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  -0x5c(%rbp),%xmm3
mulss  -0x5c(%rbp),%xmm3
movss  -0x50(%rbp),%xmm4
movss  0xde9(%rip),%xmm1
addss  -0x5c(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  0xdca(%rip),%xmm1
addss  -0x5c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm4
movss  0xdb8(%rip),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xd81(%rip),%xmm1
addss  -0x5c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  0xd6f(%rip),%xmm3
addss  %xmm3,%xmm2
movss  -0x5c(%rbp),%xmm3
movss  -0x5c(%rbp),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x5c(%rbp),%xmm2
mulss  -0x5c(%rbp),%xmm2
mulss  -0x5c(%rbp),%xmm2
mulss  -0x60(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
movss  0xd22(%rip),%xmm1
addss  -0x5c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm1
movss  0xceb(%rip),%xmm0
addss  -0x5c(%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  -0x5c(%rbp),%xmm2
movss  0xcba(%rip),%xmm1
addss  %xmm1,%xmm2
movss  -0x5c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm0
call   1030 <isfinite@plt>
cmp    $0x0,%rax
je     1414 <smf3lowres+0x2e4>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    148c <smf3lowres+0x35c>
movss  -0x50(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     1435 <smf3lowres+0x305>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
jmp    1482 <smf3lowres+0x352>
movss  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    145b <smf3lowres+0x32b>
mov    0x2ba3(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    1478 <smf3lowres+0x348>
mov    0x2b8e(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x54(%rbp),%xmm0
call   1030 <isfinite@plt>
cmp    $0x0,%rax
je     14b9 <smf3lowres+0x389>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
jmp    1531 <smf3lowres+0x401>
movss  -0x54(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     14da <smf3lowres+0x3aa>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    1527 <smf3lowres+0x3f7>
movss  -0x54(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1500 <smf3lowres+0x3d0>
mov    0x2afe(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    151d <smf3lowres+0x3ed>
mov    0x2ae9(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
call   1030 <isfinite@plt>
cmp    $0x0,%rax
je     155e <smf3lowres+0x42e>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    15df <smf3lowres+0x4af>
movss  -0x58(%rbp),%xmm0
call   1040 <isnan@plt>
cmp    $0x0,%rax
je     157f <smf3lowres+0x44f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
jmp    15d5 <smf3lowres+0x4a5>
movss  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    15a8 <smf3lowres+0x478>
mov    0x2a59(%rip),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    15c8 <smf3lowres+0x498>
mov    0x2a41(%rip),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%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    1182 <smf3lowres+0x52>
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<smf3lowres>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
movss  (%rdi),%xmm0
movaps %xmm0,0x20(%rsp)
movss  0x4(%rdi),%xmm4
mov    %rdi,0x38(%rsp)
movss  0x8(%rdi),%xmm1
test   %esi,%esi
jle    144a <smf3lowres+0x31a>
mov    %r9,%r15
mov    %r8,%r12
mov    %rcx,%r13
mov    %rdx,%rbx
mov    %esi,%ebp
xor    %r14d,%r14d
jmp    11a7 <smf3lowres+0x77>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm3
movaps 0x10(%rsp),%xmm4
movss  %xmm3,(%rbx,%r14,4)
add    $0x1,%r14
movaps %xmm0,%xmm1
cmp    %r14,%rbp
je     144d <smf3lowres+0x31d>
movss  %xmm1,0x8(%rsp)
movss  %xmm4,0x10(%rsp)
movss  (%r12,%r14,4),%xmm0
call   1050 <smff2w_2@plt>
movss  (%r15,%r14,4),%xmm6
mulss  0xe34(%rip),%xmm6
movaps %xmm0,%xmm2
addss  0xe2d(%rip),%xmm2
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm1,%xmm7
addss  %xmm2,%xmm7
movaps %xmm2,%xmm5
mulss  %xmm7,%xmm5
movaps %xmm0,%xmm3
mulss  %xmm2,%xmm3
mulss  0x10(%rsp),%xmm3
movaps %xmm0,%xmm9
mulss  %xmm1,%xmm9
movaps 0x20(%rsp),%xmm8
mulss  %xmm8,%xmm1
addss  %xmm3,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm2,%xmm3
mulss  0x8(%rsp),%xmm3
addss  %xmm1,%xmm3
xorps  0xde7(%rip),%xmm3
unpcklps %xmm9,%xmm3
shufps $0x0,%xmm6,%xmm6
mulps  %xmm3,%xmm6
unpcklps %xmm2,%xmm5
movss  0x0(%r13,%r14,4),%xmm3
movaps %xmm7,0x50(%rsp)
unpcklps %xmm7,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm6,%xmm3
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
divss  %xmm1,%xmm3
subss  %xmm8,%xmm3
movaps %xmm2,0x40(%rsp)
divss  %xmm2,%xmm3
movss  %xmm0,0x4(%rsp)
mulss  %xmm0,%xmm3
addss  %xmm3,%xmm8
movss  %xmm8,0xc(%rsp)
addss  %xmm8,%xmm3
movaps %xmm3,0x20(%rsp)
movaps %xmm3,%xmm0
call   1030 <isfinite@plt>
test   %rax,%rax
je     12c0 <smf3lowres+0x190>
movaps 0x20(%rsp),%xmm3
movss  0x8(%rsp),%xmm2
movss  0x4(%rsp),%xmm4
movss  0x10(%rsp),%xmm5
movaps 0x50(%rsp),%xmm6
movaps 0x40(%rsp),%xmm7
movss  0xc(%rsp),%xmm0
jmp    1320 <smf3lowres+0x1f0>
nopl   0x0(%rax,%rax,1)
movaps 0x20(%rsp),%xmm0
call   1040 <isnan@plt>
xorps  %xmm3,%xmm3
test   %rax,%rax
movss  0x8(%rsp),%xmm2
movss  0x4(%rsp),%xmm4
movss  0x10(%rsp),%xmm5
movaps 0x50(%rsp),%xmm6
movaps 0x40(%rsp),%xmm7
movss  0xc(%rsp),%xmm0
jne    1320 <smf3lowres+0x1f0>
mov    0x2cf5(%rip),%rax
movss  (%rax),%xmm1
xorps  %xmm3,%xmm3
cmpltss 0x20(%rsp),%xmm3
movaps %xmm3,%xmm8
andps  %xmm1,%xmm8
xorps  0xcf8(%rip),%xmm1
andnps %xmm1,%xmm3
orps   %xmm8,%xmm3
nop
movaps %xmm3,0x20(%rsp)
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm0
subss  %xmm2,%xmm0
divss  %xmm6,%xmm0
mulss  %xmm4,%xmm0
addss  %xmm0,%xmm5
movss  %xmm5,0x10(%rsp)
addss  %xmm5,%xmm0
movss  %xmm0,0xc(%rsp)
call   1030 <isfinite@plt>
test   %rax,%rax
je     1380 <smf3lowres+0x250>
movss  0xc(%rsp),%xmm5
movss  0x8(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
movss  0x10(%rsp),%xmm4
jmp    13d0 <smf3lowres+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0xc(%rsp),%xmm0
call   1040 <isnan@plt>
xorps  %xmm5,%xmm5
test   %rax,%rax
movss  0x8(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
movss  0x10(%rsp),%xmm4
jne    13d0 <smf3lowres+0x2a0>
mov    0x2c44(%rip),%rax
movss  (%rax),%xmm3
xorps  %xmm5,%xmm5
cmpltss 0xc(%rsp),%xmm5
movaps %xmm5,%xmm1
andps  %xmm3,%xmm1
xorps  0xc49(%rip),%xmm3
andnps %xmm3,%xmm5
orps   %xmm1,%xmm5
nopl   (%rax)
movaps %xmm5,0x10(%rsp)
mulss  %xmm4,%xmm0
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rsp)
addss  %xmm2,%xmm0
movss  %xmm0,0x4(%rsp)
call   1030 <isfinite@plt>
test   %rax,%rax
jne    1180 <smf3lowres+0x50>
movss  0x4(%rsp),%xmm0
call   1040 <isnan@plt>
xorps  %xmm0,%xmm0
test   %rax,%rax
movss  0x8(%rsp),%xmm3
movaps 0x10(%rsp),%xmm4
jne    1191 <smf3lowres+0x61>
mov    0x2bcc(%rip),%rax
movss  (%rax),%xmm1
xorps  %xmm0,%xmm0
cmpltss 0x4(%rsp),%xmm0
movaps %xmm0,%xmm2
andps  %xmm1,%xmm2
xorps  0xbd1(%rip),%xmm1
andnps %xmm1,%xmm0
orps   %xmm2,%xmm0
jmp    1191 <smf3lowres+0x61>
movaps %xmm1,%xmm0
mov    0x38(%rsp),%rax
movaps 0x20(%rsp),%xmm1
movss  %xmm1,(%rax)
movss  %xmm4,0x4(%rax)
movss  %xmm0,0x8(%rax)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@HUGE_VALF = global float 0.000000e+00
define void @smf3lowres(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 = icmp sgt i32 %1, 0
br i1 %12, label %13, label %103
13: ; preds = %6
%14 = zext i32 %1 to i64
br label %15
15: ; preds = %13, %98
%16 = phi i64 [ 0, %13 ], [ %101, %98 ]
%17 = phi float [ %7, %13 ], [ %75, %98 ]
%18 = phi float [ %11, %13 ], [ %99, %98 ]
%19 = phi float [ %9, %13 ], [ %87, %98 ]
%20 = getelementptr inbounds float, float* %4, i64 %16
%21 = load float, float* %20
%22 = tail call float @smff2w_2(float %21)
%23 = getelementptr inbounds float, float* %5, i64 %16
%24 = load float, float* %23
%25 = fmul float %24, 3.000000e+00
%26 = fadd float %22, 1.000000e+00
%27 = tail call float @llvm.fmuladd.f32(float %22, float %22, float %26)
%28 = fmul float %26, %27
%29 = getelementptr inbounds float, float* %3, i64 %16
%30 = load float, float* %29
%31 = fmul float %22, %22
%32 = fmul float %22, %26
%33 = fmul float %19, %32
%34 = tail call float @llvm.fmuladd.f32(float %31, float %17, float %33)
%35 = fmul float %26, %26
%36 = tail call float @llvm.fmuladd.f32(float %35, float %18, float %34)
%37 = fneg float %36
%38 = fmul float %22, %31
%39 = insertelement <2 x float> poison, float %25, i64 0
%40 = shufflevector <2 x float> %39, <2 x float> poison, <2 x i32> zeroinitializer
%41 = insertelement <2 x float> poison, float %37, i64 0
%42 = insertelement <2 x float> %41, float %38, i64 1
%43 = fmul <2 x float> %40, %42
%44 = insertelement <2 x float> poison, float %28, i64 0
%45 = insertelement <2 x float> %44, float %26, i64 1
%46 = insertelement <2 x float> poison, float %30, i64 0
%47 = insertelement <2 x float> %46, float %27, i64 1
%48 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %45, <2 x float> %47, <2 x float> %43)
%49 = extractelement <2 x float> %48, i64 0
%50 = extractelement <2 x float> %48, i64 1
%51 = fdiv float %49, %50
%52 = fsub float %51, %17
%53 = fdiv float %52, %26
%54 = tail call float @llvm.fmuladd.f32(float %22, float %53, float %17)
%55 = fneg float %26
%56 = tail call float @llvm.fmuladd.f32(float %55, float %19, float %54)
%57 = fsub float %56, %18
%58 = fdiv float %57, %27
%59 = tail call float @llvm.fmuladd.f32(float %22, float %58, float %19)
%60 = tail call float @llvm.fmuladd.f32(float %22, float %59, float %18)
%61 = tail call float @llvm.fmuladd.f32(float %22, float %53, float %54)
%62 = tail call float @llvm.fmuladd.f32(float %22, float %58, float %59)
%63 = tail call float @llvm.fmuladd.f32(float %22, float %59, float %60)
%64 = tail call i64 @isfinite(float %61)
%65 = icmp eq i64 %64, 0
br i1 %65, label %66, label %74
66: ; preds = %15
%67 = tail call i64 @isnan(float %61)
%68 = icmp eq i64 %67, 0
br i1 %68, label %69, label %74
69: ; preds = %66
%70 = fcmp ogt float %61, 0.000000e+00
%71 = load float, float* @HUGE_VALF
%72 = fneg float %71
%73 = select i1 %70, float %71, float %72
br label %74
74: ; preds = %15, %69, %66
%75 = phi float [ %73, %69 ], [ 0.000000e+00, %66 ], [ %61, %15 ]
%76 = tail call i64 @isfinite(float %62)
%77 = icmp eq i64 %76, 0
br i1 %77, label %78, label %86
78: ; preds = %74
%79 = tail call i64 @isnan(float %62)
%80 = icmp eq i64 %79, 0
br i1 %80, label %81, label %86
81: ; preds = %78
%82 = fcmp ogt float %62, 0.000000e+00
%83 = load float, float* @HUGE_VALF
%84 = fneg float %83
%85 = select i1 %82, float %83, float %84
br label %86
86: ; preds = %74, %81, %78
%87 = phi float [ %85, %81 ], [ 0.000000e+00, %78 ], [ %62, %74 ]
%88 = tail call i64 @isfinite(float %63)
%89 = icmp eq i64 %88, 0
br i1 %89, label %90, label %98
90: ; preds = %86
%91 = tail call i64 @isnan(float %63)
%92 = icmp eq i64 %91, 0
br i1 %92, label %93, label %98
93: ; preds = %90
%94 = fcmp ogt float %63, 0.000000e+00
%95 = load float, float* @HUGE_VALF
%96 = fneg float %95
%97 = select i1 %94, float %95, float %96
br label %98
98: ; preds = %86, %93, %90
%99 = phi float [ %97, %93 ], [ 0.000000e+00, %90 ], [ %63, %86 ]
%100 = getelementptr inbounds float, float* %2, i64 %16
store float %60, float* %100
%101 = add nuw nsw i64 %16, 1
%102 = icmp eq i64 %101, %14
br i1 %102, label %103, label %15
103: ; preds = %98, %6
%104 = phi float [ %9, %6 ], [ %87, %98 ]
%105 = phi float [ %11, %6 ], [ %99, %98 ]
%106 = phi float [ %7, %6 ], [ %75, %98 ]
store float %106, float* %0
store float %104, float* %8
store float %105, float* %10
ret void
}