#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 pow(float, int);
float sqrt(float);
float target_y(float *x, float *dx, int m) {
  int ncoeff = 10;
  float avdat = 0.2411373E+01;
  float xmin[10] = {-0.15000E+02, -0.15000E+02, -0.18000E+02, -0.18013E+02,
                    0.00000E+00,  0.00000E+00,  0.00000E+00,  0.00000E+00,
                    0.00000E+00,  0.00000E+00};
  float xmax[10] = {0.15000E+02, 0.15000E+02, 0.18000E+02, 0.17988E+02,
                    0.00000E+00, 0.00000E+00, 0.00000E+00, 0.00000E+00,
                    0.00000E+00, 0.00000E+00};
  float scale[10] = {0};
  float coeff[11] = {-0.18069027E-01,
                     -0.38414059E+02,
                     0.64050293E+02,
                     -0.50189286E+00,
                     0.45033842E+00,
                     -0.17961334E+00,
                     0.13912536E+00,
                     0.52676702E+00,
                     -0.36718246E+00,
                     -0.11600584E-02,
                     0.};
  int ientry = 0;
  int i;
  if (ientry == 0) {
    ientry = 1;
    for (i = 0; i < m; i++) {
      if (xmin[i] == xmax[i])
        continue;
      scale[i] = 2. / (xmax[i] - xmin[i]);
    }
  }
  float x1 = 1. + (x[0] - xmax[0]) * scale[0];
  float dx1 = dx[0] * scale[0];
  float x2 = 1. + (x[1] - xmax[1]) * scale[1];
  float dx2 = dx[1] * scale[1];
  float x3 = 1. + (x[2] - xmax[2]) * scale[2];
  float dx3 = dx[2] * scale[2];
  float x4 = 1. + (x[3] - xmax[3]) * scale[3];
  float dx4 = dx[3] * scale[3];
  float x11 = x1;
  float x12 = x11 * x1;
  float x21 = x2;
  float x22 = x21 * x2;
  float x31 = x3;
  float x32 = x31 * x3;
  float x41 = x4;
  float x42 = x41 * x4;
  float v_target_y = avdat + coeff[0] + coeff[1] * x21 + coeff[2] * x41 +
                     coeff[3] * x21 * x41 + coeff[4] * x42 + coeff[5] * x12 +
                     coeff[6] * x22 + coeff[7] * x11 * x31;
  v_target_y = v_target_y + coeff[8] * x32 + coeff[9] * x21 * x32;
  float dxall = 0 + dx1 + dx2 + dx3 + dx4;
  float dv_target_y =
      dxall == 0
          ? 0
          : sqrt(
                +dx1 * dx1 * pow(0 + 2 * coeff[5] * x11 + coeff[7] * x31, 2) +
                dx2 * dx2 *
                    pow(0 + coeff[1] + coeff[3] * x41 + 2 * coeff[6] * x21 +
                            coeff[9] * x32,
                        2) +
                dx3 * dx3 *
                    pow(0 + coeff[7] * x11 + 2 * coeff[8] * x31 +
                            2 * coeff[9] * x31 * x21,
                        2) +
                dx4 * dx4 *
                    pow(0 + coeff[2] + coeff[3] * x21 + 2 * coeff[4] * x41, 2));
  dx[0] = dv_target_y;
  return v_target_y;
}


x86 assembly (clang, -O0):
<target_y>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0xa,-0x18(%rbp)
movss  0xeb3(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
movss  0xe92(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0xe85(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xe74(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xe63(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
movss  0xe42(%rip),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  0xe35(%rip),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  0xe24(%rip),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  0xe13(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
lea    -0xe0(%rbp),%rdi
lea    0xe1d(%rip),%rsi
mov    $0x2c,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0xe4(%rbp)
cmpl   $0x0,-0xe4(%rbp)
jne    12d8 <target_y+0x198>
movl   $0x1,-0xe4(%rbp)
movl   $0x0,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d3 <target_y+0x193>
movslq -0xe8(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0xe8(%rbp),%rax
ucomiss -0x80(%rbp,%rax,4),%xmm0
jne    1281 <target_y+0x141>
jp     1281 <target_y+0x141>
jmp    12bf <target_y+0x17f>
movslq -0xe8(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm0
movslq -0xe8(%rbp),%rax
subss  -0x50(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd81(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0xe8(%rbp),%rax
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    1248 <target_y+0x108>
jmp    12d8 <target_y+0x198>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x80(%rbp),%xmm0
mulss  -0xb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xd27(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x7c(%rbp),%xmm0
mulss  -0xac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xcdd(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  -0x78(%rbp),%xmm0
mulss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc92(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  -0x74(%rbp),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc47(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
mulss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
mulss  -0xf4(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xfc(%rbp),%xmm0
ff
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0x11c(%rbp),%xmm0
ff
mulss  -0xfc(%rbp),%xmm0
ff
movss  %xmm0,-0x120(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x124(%rbp)
ff
movss  -0x124(%rbp),%xmm0
ff
mulss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x128(%rbp)
ff
movss  -0x1c(%rbp),%xmm1
addss  -0xe0(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xd8(%rbp),%xmm1
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0x114(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xd0(%rbp),%xmm1
ff
movss  -0x128(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x110(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc8(%rbp),%xmm1
ff
movss  -0x118(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
mulss  -0x10c(%rbp),%xmm0
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x12c(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm1
ff
movss  -0x120(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xbc(%rbp),%xmm0
ff
mulss  -0x114(%rbp),%xmm0
ff
movss  -0x120(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xf0(%rbp),%xmm0
ff
addss  -0xf8(%rbp),%xmm0
ff
addss  -0x100(%rbp),%xmm0
ff
addss  -0x108(%rbp),%xmm0
ff
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    160c <target_y+0x4cc>
jp     160c <target_y+0x4cc>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x138(%rbp)
ff
jmp    1852 <target_y+0x712>
movss  -0xf0(%rbp),%xmm0
ff
mulss  -0xf0(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  0x9f0(%rip),%xmm1
mulss  -0xcc(%rbp),%xmm1
ff
movss  -0x10c(%rbp),%xmm0
ff
mulss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  %xmm0,-0x150(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
mulss  -0xf8(%rbp),%xmm0
ff
movss  %xmm0,-0x154(%rbp)
ff
xorps  %xmm1,%xmm1
addss  -0xdc(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x968(%rip),%xmm1
mulss  -0xc8(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xbc(%rbp),%xmm0
ff
movss  -0x120(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x154(%rbp),%xmm1
ff
movss  -0x150(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movss  -0x14c(%rbp),%xmm0
ff
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x148(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
mulss  -0x100(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
addss  %xmm1,%xmm0
movss  0x8c4(%rip),%xmm1
mulss  -0xc0(%rbp),%xmm1
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x8a4(%rip),%xmm0
mulss  -0xbc(%rbp),%xmm0
ff
mulss  -0x11c(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x148(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x144(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x140(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
mulss  -0x108(%rbp),%xmm0
ff
movss  %xmm0,-0x13c(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xd8(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x814(%rip),%xmm0
mulss  -0xd0(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x140(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x13c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x138(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x12c(%rbp),%xmm0
ff
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<target_y>:
push   %rbx
sub    $0x100,%rsp
mov    %rsi,%rbx
xorps  %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
movq   $0x0,0xf0(%rsp)
movaps 0xeb7(%rip),%xmm1
movaps %xmm1,0xd0(%rsp)
movaps %xmm0,0xb0(%rsp)
movq   $0x0,0xc0(%rsp)
movaps 0xea4(%rip),%xmm1
movaps %xmm1,0xa0(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movq   $0x0,0x80(%rsp)
xorps  %xmm1,%xmm1
test   %edx,%edx
jle    1201 <target_y+0xe1>
mov    %edx,%eax
add    $0xffffffffffffffff,%rax
movss  0xe81(%rip),%xmm2
movss  0xe7d(%rip),%xmm1
xor    %ecx,%ecx
movss  0xe77(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomiss %xmm1,%xmm2
jne    11c7 <target_y+0xa7>
jnp    11d8 <target_y+0xb8>
subss  %xmm2,%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x60(%rsp,%rcx,4)
cmp    %rcx,%rax
je     11f5 <target_y+0xd5>
movss  0xd4(%rsp,%rcx,4),%xmm2
movss  0xa4(%rsp,%rcx,4),%xmm1
add    $0x1,%rcx
jmp    11c0 <target_y+0xa0>
movsd  0x60(%rsp),%xmm1
movsd  0x68(%rsp),%xmm0
movss  0xe17(%rip),%xmm2
movss  (%rdi),%xmm6
addss  %xmm2,%xmm6
mulss  %xmm1,%xmm6
movss  0xe0f(%rip),%xmm4
addss  %xmm4,%xmm6
addss  0x4(%rdi),%xmm2
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
movsd  (%rbx),%xmm5
movsd  0x8(%rbx),%xmm2
mulps  %xmm1,%xmm5
movaps %xmm5,%xmm8
shufps $0x55,%xmm5,%xmm8
movss  0x8(%rdi),%xmm9
movss  0xc(%rdi),%xmm1
addss  0xdd2(%rip),%xmm9
mulss  %xmm0,%xmm9
addss  %xmm4,%xmm9
addss  0xdc4(%rip),%xmm1
movaps %xmm0,%xmm7
shufps $0x55,%xmm0,%xmm7
mulss  %xmm1,%xmm7
addss  %xmm4,%xmm7
mulps  %xmm0,%xmm2
movaps %xmm2,%xmm4
shufps $0x55,%xmm2,%xmm4
movaps %xmm9,%xmm10
mulss  %xmm9,%xmm10
xorps  %xmm0,%xmm0
movaps %xmm5,%xmm1
addss  %xmm0,%xmm1
addss  %xmm8,%xmm1
addss  %xmm2,%xmm1
addss  %xmm4,%xmm1
ucomiss %xmm0,%xmm1
jne    12b4 <target_y+0x194>
jnp    147b <target_y+0x35b>
mulss  %xmm5,%xmm5
movaps %xmm5,0x90(%rsp)
movss  0xd70(%rip),%xmm1
mulss  %xmm6,%xmm1
xorps  %xmm0,%xmm0
addss  %xmm0,%xmm1
movaps %xmm9,%xmm0
mulss  0xd5d(%rip),%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
movss  %xmm6,0x8(%rsp)
movss  %xmm9,0x4(%rsp)
movaps %xmm3,0x20(%rsp)
movss  %xmm10,(%rsp)
movaps %xmm7,0x30(%rsp)
movaps %xmm2,0x10(%rsp)
movaps %xmm4,0x50(%rsp)
movaps %xmm8,0x40(%rsp)
call   1030 <pow@plt>
movss  %xmm0,0xc(%rsp)
movaps 0x40(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0x30(%rsp),%xmm0
mulss  0xd05(%rip),%xmm0
addss  0xd01(%rip),%xmm0
movss  0xcfd(%rip),%xmm1
mulss  0x20(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  0xcef(%rip),%xmm0
mulss  (%rsp),%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x40(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
mulss  0x90(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
movaps 0x10(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
movss  0xc97(%rip),%xmm0
mulss  0x8(%rsp),%xmm0
addss  0xcc1(%rip),%xmm0
movss  0xc95(%rip),%xmm1
movss  0x4(%rsp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0xc83(%rip),%xmm0
mulss  %xmm2,%xmm0
mulss  0x20(%rsp),%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x10(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
movss  0xc3d(%rip),%xmm0
mulss  0x20(%rsp),%xmm0
addss  0xc47(%rip),%xmm0
movaps %xmm0,%xmm1
movaps 0x50(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movss  0xc32(%rip),%xmm0
mulss  0x30(%rsp),%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x50(%rsp),%xmm0
addss  0x10(%rsp),%xmm0
ucomiss 0xc23(%rip),%xmm0
jb     1459 <target_y+0x339>
sqrtss %xmm0,%xmm0
jmp    145e <target_y+0x33e>
call   1040 <sqrt@plt>
movss  0x8(%rsp),%xmm6
movss  0x4(%rsp),%xmm9
movaps 0x20(%rsp),%xmm3
movss  (%rsp),%xmm10
movaps 0x30(%rsp),%xmm7
movss  0xbc8(%rip),%xmm8
mulss  %xmm3,%xmm8
movss  0xbab(%rip),%xmm2
mulss  %xmm6,%xmm2
movaps %xmm3,%xmm1
mulss  %xmm3,%xmm1
movss  0xb9c(%rip),%xmm4
mulss  %xmm3,%xmm4
mulss  0xb94(%rip),%xmm3
addss  0xba8(%rip),%xmm3
mulss  %xmm6,%xmm6
movaps %xmm7,%xmm5
mulss  %xmm7,%xmm4
mulss  0xb8d(%rip),%xmm7
mulss  %xmm5,%xmm5
addss  %xmm3,%xmm7
mulss  0xb89(%rip),%xmm5
addss  %xmm4,%xmm7
addss  %xmm7,%xmm5
mulss  0xb7d(%rip),%xmm6
addss  %xmm5,%xmm6
mulss  0xb75(%rip),%xmm1
addss  %xmm6,%xmm1
mulss  %xmm9,%xmm2
mulss  %xmm10,%xmm8
mulss  0xb62(%rip),%xmm10
addss  %xmm1,%xmm2
addss  %xmm2,%xmm10
addss  %xmm8,%xmm10
movss  %xmm0,(%rbx)
movaps %xmm10,%xmm0
add    $0x100,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define float @target_y(float* nocapture %0, float* nocapture %1, i32 %2) {
%4 = alloca [10 x float]
%5 = alloca [10 x float]
%6 = alloca [10 x float]
%7 = bitcast [10 x float]* %4 to i8*
%8 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 4
%9 = bitcast float* %8 to i8*
%10 = bitcast [10 x float]* %4 to <4 x float>*
store <4 x float> <float -1.500000e+01, float -1.500000e+01, float -1.800000e+01, float 0xC032035400000000>, <4 x float>* %10
%11 = bitcast [10 x float]* %5 to i8*
%12 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 4
%13 = bitcast float* %12 to i8*
%14 = bitcast [10 x float]* %5 to <4 x float>*
store <4 x float> <float 1.500000e+01, float 1.500000e+01, float 1.800000e+01, float 0x4031FCEDA0000000>, <4 x float>* %14
%15 = bitcast [10 x float]* %6 to i8*
%16 = icmp sgt i32 %2, 0
br i1 %16, label %17, label %42
17: ; preds = %3
%18 = zext i32 %2 to i64
br label %19
19: ; preds = %31, %17
%20 = phi float [ 1.500000e+01, %17 ], [ %35, %31 ]
%21 = phi float [ -1.500000e+01, %17 ], [ %33, %31 ]
%22 = phi i64 [ 0, %17 ], [ %29, %31 ]
%23 = fcmp oeq float %21, %20
br i1 %23, label %28, label %24
24: ; preds = %19
%25 = fsub float %20, %21
%26 = fdiv float 2.000000e+00, %25
%27 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 %22
store float %26, float* %27
br label %28
28: ; preds = %19, %24
%29 = add nuw nsw i64 %22, 1
%30 = icmp eq i64 %29, %18
br i1 %30, label %36, label %31
31: ; preds = %28
%32 = getelementptr inbounds [10 x float], [10 x float]* %4, i64 0, i64 %29
%33 = load float, float* %32
%34 = getelementptr inbounds [10 x float], [10 x float]* %5, i64 0, i64 %29
%35 = load float, float* %34
br label %19
36: ; preds = %28
%37 = bitcast [10 x float]* %6 to <2 x float>*
%38 = load <2 x float>, <2 x float>* %37
%39 = getelementptr inbounds [10 x float], [10 x float]* %6, i64 0, i64 2
%40 = bitcast float* %39 to <2 x float>*
%41 = load <2 x float>, <2 x float>* %40
br label %42
42: ; preds = %36, %3
%43 = phi <2 x float> [ %41, %36 ], [ zeroinitializer, %3 ]
%44 = phi <2 x float> [ %38, %36 ], [ zeroinitializer, %3 ]
%45 = load float, float* %0
%46 = fadd float %45, -1.500000e+01
%47 = extractelement <2 x float> %44, i64 0
%48 = fmul float %46, %47
%49 = fadd float %48, 1.000000e+00
%50 = getelementptr inbounds float, float* %0, i64 1
%51 = load float, float* %50
%52 = fadd float %51, -1.500000e+01
%53 = extractelement <2 x float> %44, i64 1
%54 = fmul float %52, %53
%55 = fadd float %54, 1.000000e+00
%56 = bitcast float* %1 to <2 x float>*
%57 = load <2 x float>, <2 x float>* %56
%58 = fmul <2 x float> %44, %57
%59 = getelementptr inbounds float, float* %0, i64 2
%60 = load float, float* %59
%61 = fadd float %60, -1.800000e+01
%62 = extractelement <2 x float> %43, i64 0
%63 = fmul float %61, %62
%64 = fadd float %63, 1.000000e+00
%65 = getelementptr inbounds float, float* %1, i64 2
%66 = getelementptr inbounds float, float* %0, i64 3
%67 = load float, float* %66
%68 = fadd float %67, 0xC031FCEDA0000000
%69 = extractelement <2 x float> %43, i64 1
%70 = fmul float %68, %69
%71 = fadd float %70, 1.000000e+00
%72 = bitcast float* %65 to <2 x float>*
%73 = load <2 x float>, <2 x float>* %72
%74 = fmul <2 x float> %43, %73
%75 = fmul float %64, %64
%76 = extractelement <2 x float> %58, i64 0
%77 = fadd float %76, 0.000000e+00
%78 = extractelement <2 x float> %58, i64 1
%79 = fadd float %77, %78
%80 = extractelement <2 x float> %74, i64 0
%81 = fadd float %79, %80
%82 = extractelement <2 x float> %74, i64 1
%83 = fadd float %81, %82
%84 = fcmp oeq float %83, 0.000000e+00
br i1 %84, label %112, label %85
85: ; preds = %42
%86 = fmul <2 x float> %58, %58
%87 = extractelement <2 x float> %86, i64 0
%88 = tail call float @llvm.fmuladd.f32(float %49, float 0xBFD6FD91E0000000, float 0.000000e+00)
%89 = tail call float @llvm.fmuladd.f32(float %64, float 0x3FE0DB4680000000, float %88)
%90 = tail call float @pow(float %89, i32 2)
%91 = fmul float %78, %78
%92 = tail call float @llvm.fmuladd.f32(float %71, float 0xBFE00F81A0000000, float 0xC04334FFE0000000)
%93 = tail call float @llvm.fmuladd.f32(float %55, float 0x3FD1CEDC20000000, float %92)
%94 = tail call float @llvm.fmuladd.f32(float %75, float 0xBF5301A340000000, float %93)
%95 = tail call float @pow(float %94, i32 2)
%96 = fmul float %91, %95
%97 = tail call float @llvm.fmuladd.f32(float %87, float %90, float %96)
%98 = fmul <2 x float> %74, %74
%99 = extractelement <2 x float> %98, i64 0
%100 = tail call float @llvm.fmuladd.f32(float %49, float 0x3FE0DB4680000000, float 0.000000e+00)
%101 = tail call float @llvm.fmuladd.f32(float %64, float 0xBFE77FEAE0000000, float %100)
%102 = fmul float %64, 0xBF6301A340000000
%103 = tail call float @llvm.fmuladd.f32(float %102, float %55, float %101)
%104 = tail call float @pow(float %103, i32 2)
%105 = tail call float @llvm.fmuladd.f32(float %99, float %104, float %97)
%106 = fmul float %82, %82
%107 = tail call float @llvm.fmuladd.f32(float %55, float 0xBFE00F81A0000000, float 0x4050033800000000)
%108 = tail call float @llvm.fmuladd.f32(float %71, float 0x3FECD25840000000, float %107)
%109 = tail call float @pow(float %108, i32 2)
%110 = tail call float @llvm.fmuladd.f32(float %106, float %109, float %105)
%111 = tail call float @sqrt(float %110)
br label %112
112: ; preds = %42, %85
%113 = phi float [ %111, %85 ], [ 0.000000e+00, %42 ]
%114 = fmul float %55, 0xBF5301A340000000
%115 = fmul float %49, 0x3FE0DB4680000000
%116 = fmul float %55, %55
%117 = fmul float %49, %49
%118 = fmul float %71, %71
%119 = fmul float %55, 0xBFE00F81A0000000
%120 = tail call float @llvm.fmuladd.f32(float %55, float 0xC04334FFE0000000, float 0x4003257C80000000)
%121 = tail call float @llvm.fmuladd.f32(float %71, float 0x4050033800000000, float %120)
%122 = tail call float @llvm.fmuladd.f32(float %119, float %71, float %121)
%123 = tail call float @llvm.fmuladd.f32(float %118, float 0x3FDCD25840000000, float %122)
%124 = tail call float @llvm.fmuladd.f32(float %117, float 0xBFC6FD91E0000000, float %123)
%125 = tail call float @llvm.fmuladd.f32(float %116, float 0x3FC1CEDC20000000, float %124)
%126 = tail call float @llvm.fmuladd.f32(float %115, float %64, float %125)
%127 = tail call float @llvm.fmuladd.f32(float %75, float 0xBFD77FEAE0000000, float %126)
%128 = tail call float @llvm.fmuladd.f32(float %114, float %75, float %127)
store float %113, float* %1
ret float %128
}