#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 = 14;
  float avdat = 0.2300784E+02;
  float xmin[10] = {-0.15000E+02, -0.15000E+02, -0.18003E+02, -0.18010E+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.18010E+02, 0.18002E+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[15] = {-0.91933832E-02, -0.55303373E+01, -0.37732525E+02,
                     0.90797615E+01,  0.63031212E+02,  0.17328939E+00,
                     0.54065462E-01,  0.20011730E-01,  -0.12977852E-01,
                     -0.19416219E+00, 0.25011599E-01,  -0.19447805E-01,
                     0.48788274E-02,  -0.24000464E-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 x13 = x12 * x1;
  float x14 = x13 * 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] * x11 + coeff[2] * x21 +
                     coeff[3] * x31 + coeff[4] * x41 + coeff[5] * x32 +
                     coeff[6] * x12 + coeff[7] * x21 * x41;
  v_target_y = v_target_y + coeff[8] * x22 + coeff[9] * x11 * x31 +
               coeff[10] * x11 * x41 + coeff[11] * x11 * x21 +
               coeff[12] * x11 * x32 * x42 + coeff[13] * x14 * x22 * x31;
  float dxall = 0 + dx1 + dx2 + dx3 + dx4;
  float dv_target_y =
      dxall == 0
          ? 0
          : sqrt(+dx1 * dx1 *
                     pow(0 + coeff[1] + 2 * coeff[6] * x11 + coeff[9] * x31 +
                             coeff[10] * x41 + coeff[11] * x21 +
                             coeff[12] * x32 * x42 +
                             4 * coeff[13] * x13 * x22 * x31,
                         2) +
                 dx2 * dx2 *
                     pow(0 + coeff[2] + coeff[7] * x41 + 2 * coeff[8] * x21 +
                             coeff[11] * x11 + 2 * coeff[13] * x21 * x14 * x31,
                         2) +
                 dx3 * dx3 *
                     pow(0 + coeff[3] + 2 * coeff[5] * x31 + coeff[9] * x11 +
                             2 * coeff[12] * x31 * x11 * x42 +
                             coeff[13] * x14 * x22,
                         2) +
                 dx4 * dx4 *
                     pow(0 + coeff[4] + coeff[7] * x21 + coeff[10] * x11 +
                             2 * coeff[12] * x41 * x11 * x32,
                         2));
  dx[0] = dv_target_y;
  return v_target_y;
}


x86 assembly (clang, -O0):
<target_y>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0xe,-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    -0xf0(%rbp),%rdi
lea    0xe2d(%rip),%rsi
mov    $0x3c,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0xf4(%rbp)
cmpl   $0x0,-0xf4(%rbp)
jne    12d8 <target_y+0x198>
movl   $0x1,-0xf4(%rbp)
movl   $0x0,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d3 <target_y+0x193>
movslq -0xf8(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0xf8(%rbp),%rax
ucomiss -0x80(%rbp,%rax,4),%xmm0
jne    1281 <target_y+0x141>
jp     1281 <target_y+0x141>
jmp    12bf <target_y+0x17f>
movslq -0xf8(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm0
movslq -0xf8(%rbp),%rax
subss  -0x50(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd89(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0xf8(%rbp),%rax
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%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  0xd2f(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x7c(%rbp),%xmm0
mulss  -0xac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xce5(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0x108(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  -0x78(%rbp),%xmm0
mulss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc9a(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  -0x74(%rbp),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc4f(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mulss  -0xa4(%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  -0x120(%rbp),%xmm0
ff
mulss  -0xfc(%rbp),%xmm0
ff
movss  %xmm0,-0x124(%rbp)
ff
movss  -0x124(%rbp),%xmm0
ff
mulss  -0xfc(%rbp),%xmm0
ff
movss  %xmm0,-0x128(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x12c(%rbp),%xmm0
ff
mulss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
mulss  -0x10c(%rbp),%xmm0
ff
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  %xmm0,-0x13c(%rbp)
ff
movss  -0x13c(%rbp),%xmm0
ff
mulss  -0x114(%rbp),%xmm0
ff
movss  %xmm0,-0x140(%rbp)
ff
movss  -0x1c(%rbp),%xmm1
addss  -0xf0(%rbp),%xmm1
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xe8(%rbp),%xmm1
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xe0(%rbp),%xmm1
ff
movss  -0x13c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x138(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xd8(%rbp),%xmm1
ff
movss  -0x120(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0x12c(%rbp),%xmm0
ff
movss  -0x13c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0x130(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0x11c(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc8(%rbp),%xmm1
ff
mulss  -0x11c(%rbp),%xmm1
ff
movss  -0x13c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
mulss  -0x11c(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc0(%rbp),%xmm1
ff
mulss  -0x11c(%rbp),%xmm1
ff
mulss  -0x138(%rbp),%xmm1
ff
movss  -0x140(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xbc(%rbp),%xmm0
ff
mulss  -0x128(%rbp),%xmm0
ff
mulss  -0x130(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0x100(%rbp),%xmm0
ff
addss  -0x108(%rbp),%xmm0
ff
addss  -0x110(%rbp),%xmm0
ff
addss  -0x118(%rbp),%xmm0
ff
movss  %xmm0,-0x148(%rbp)
ff
movss  -0x148(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    16c4 <target_y+0x584>
jp     16c4 <target_y+0x584>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x150(%rbp)
ff
jmp    1a1a <target_y+0x8da>
movss  -0x100(%rbp),%xmm0
ff
mulss  -0x100(%rbp),%xmm0
ff
movss  %xmm0,-0x164(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xec(%rbp),%xmm0
ff
movss  0x92d(%rip),%xmm1
mulss  -0xd8(%rbp),%xmm1
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc8(%rbp),%xmm1
ff
movss  -0x13c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc0(%rbp),%xmm1
ff
mulss  -0x138(%rbp),%xmm1
ff
movss  -0x140(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x8a9(%rip),%xmm0
mulss  -0xbc(%rbp),%xmm0
ff
mulss  -0x124(%rbp),%xmm0
ff
mulss  -0x130(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  %xmm0,-0x168(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
mulss  -0x108(%rbp),%xmm0
ff
movss  %xmm0,-0x16c(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xe8(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm1
ff
movss  -0x13c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x828(%rip),%xmm0
mulss  -0xd0(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc4(%rbp),%xmm1
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x7f0(%rip),%xmm0
mulss  -0xbc(%rbp),%xmm0
ff
mulss  -0x12c(%rbp),%xmm0
ff
mulss  -0x128(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x16c(%rbp),%xmm1
ff
movss  -0x168(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movss  -0x164(%rbp),%xmm0
ff
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x160(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
mulss  -0x110(%rbp),%xmm0
ff
movss  %xmm0,-0x15c(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xe4(%rbp),%xmm0
ff
movss  0x764(%rip),%xmm1
mulss  -0xdc(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x72c(%rip),%xmm1
mulss  -0xc0(%rbp),%xmm1
ff
mulss  -0x134(%rbp),%xmm1
ff
mulss  -0x11c(%rbp),%xmm1
ff
movss  -0x140(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xbc(%rbp),%xmm0
ff
mulss  -0x128(%rbp),%xmm0
ff
movss  -0x130(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x160(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x15c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x158(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
movss  %xmm0,-0x154(%rbp)
ff
xorps  %xmm1,%xmm1
addss  -0xe0(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc8(%rbp),%xmm1
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x65c(%rip),%xmm0
mulss  -0xc0(%rbp),%xmm0
ff
mulss  -0x13c(%rbp),%xmm0
ff
mulss  -0x11c(%rbp),%xmm0
ff
movss  -0x138(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x158(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x154(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x150(%rbp)
ff
movss  -0x150(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x14c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x144(%rbp),%xmm0
ff
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<target_y>:
push   %rbx
sub    $0x130,%rsp
mov    %rsi,%rbx
xorps  %xmm0,%xmm0
movaps %xmm0,0x110(%rsp)
movq   $0x0,0x120(%rsp)
movaps 0xeb7(%rip),%xmm1
movaps %xmm1,0x100(%rsp)
movaps %xmm0,0xe0(%rsp)
movq   $0x0,0xf0(%rsp)
movaps 0xea4(%rip),%xmm1
movaps %xmm1,0xd0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movq   $0x0,0xb0(%rsp)
xorps  %xmm1,%xmm1
test   %edx,%edx
jle    120a <target_y+0xea>
mov    %edx,%eax
add    $0xffffffffffffffff,%rax
movss  0xe7b(%rip),%xmm2
movss  0xe77(%rip),%xmm1
xor    %ecx,%ecx
movss  0xe71(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
ucomiss %xmm1,%xmm2
jne    11c7 <target_y+0xa7>
jnp    11db <target_y+0xbb>
subss  %xmm2,%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x90(%rsp,%rcx,4)
cmp    %rcx,%rax
je     11f8 <target_y+0xd8>
movss  0x104(%rsp,%rcx,4),%xmm2
movss  0xd4(%rsp,%rcx,4),%xmm1
add    $0x1,%rcx
jmp    11c0 <target_y+0xa0>
movsd  0x90(%rsp),%xmm1
movsd  0x98(%rsp),%xmm0
movss  0xe0e(%rip),%xmm2
movss  (%rdi),%xmm7
addss  %xmm2,%xmm7
mulss  %xmm1,%xmm7
movss  0xe06(%rip),%xmm3
addss  0x4(%rdi),%xmm2
addss  %xmm3,%xmm7
movaps %xmm1,%xmm8
shufps $0x55,%xmm1,%xmm8
mulss  %xmm2,%xmm8
addss  %xmm3,%xmm8
movsd  (%rbx),%xmm5
movsd  0x8(%rbx),%xmm4
mulps  %xmm1,%xmm5
movaps %xmm5,%xmm6
shufps $0x55,%xmm5,%xmm6
movss  0x8(%rdi),%xmm9
movss  0xc(%rdi),%xmm1
addss  0xdc7(%rip),%xmm9
mulss  %xmm0,%xmm9
addss  %xmm3,%xmm9
addss  0xdb9(%rip),%xmm1
movaps %xmm0,%xmm10
shufps $0x55,%xmm0,%xmm10
mulss  %xmm1,%xmm10
addss  %xmm3,%xmm10
mulps  %xmm0,%xmm4
movaps %xmm4,%xmm3
shufps $0x55,%xmm4,%xmm3
movaps %xmm7,%xmm14
mulss  %xmm7,%xmm14
movaps %xmm7,%xmm1
mulss  %xmm14,%xmm1
movaps %xmm7,%xmm11
mulss  %xmm1,%xmm11
movaps %xmm8,%xmm12
mulss  %xmm8,%xmm12
movaps %xmm9,%xmm15
mulss  %xmm9,%xmm15
movaps %xmm10,%xmm0
mulss  %xmm10,%xmm0
movaps %xmm0,0x80(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm5,%xmm2
addss  %xmm0,%xmm2
addss  %xmm6,%xmm2
addss  %xmm4,%xmm2
addss  %xmm3,%xmm2
ucomiss %xmm0,%xmm2
movss  0xd41(%rip),%xmm13
movss  %xmm11,0x1c(%rsp)
mulss  %xmm11,%xmm13
jne    130b <target_y+0x1eb>
jnp    15b9 <target_y+0x499>
movss  %xmm14,0x18(%rsp)
mulss  %xmm5,%xmm5
movaps %xmm5,0xc0(%rsp)
movss  0xd16(%rip),%xmm0
mulss  %xmm7,%xmm0
addss  0xd0e(%rip),%xmm0
movaps %xmm9,%xmm2
mulss  0xd06(%rip),%xmm2
addss  %xmm0,%xmm2
movaps %xmm10,%xmm0
mulss  0xcfa(%rip),%xmm0
addss  %xmm2,%xmm0
movaps %xmm8,%xmm2
mulss  0xcee(%rip),%xmm2
addss  %xmm0,%xmm2
movss  0xce6(%rip),%xmm0
mulss  %xmm15,%xmm0
mulss  0x80(%rsp),%xmm0
mulss  0xcd4(%rip),%xmm1
addss  %xmm2,%xmm0
mulss  %xmm12,%xmm1
mulss  %xmm9,%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
mov    $0x2,%edi
movaps %xmm8,0x40(%rsp)
movss  %xmm9,0x8(%rsp)
movss  %xmm7,0x4(%rsp)
movaps %xmm10,0x30(%rsp)
movaps %xmm12,0x50(%rsp)
movss  %xmm13,0x10(%rsp)
movss  %xmm15,0xc(%rsp)
movaps %xmm3,0x70(%rsp)
movaps %xmm4,0x20(%rsp)
movaps %xmm6,0x60(%rsp)
call   1030 <pow@plt>
movss  %xmm0,0x14(%rsp)
movaps 0x60(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0x30(%rsp),%xmm0
mulss  0xc5c(%rip),%xmm0
addss  0xc58(%rip),%xmm0
movss  0xc54(%rip),%xmm1
movaps 0x40(%rsp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0xc2b(%rip),%xmm0
mulss  0x4(%rsp),%xmm0
addss  %xmm1,%xmm0
movaps %xmm0,%xmm3
movss  0xc2e(%rip),%xmm1
mulss  %xmm2,%xmm1
movss  0x1c(%rsp),%xmm0
mulss  %xmm1,%xmm0
mulss  0x8(%rsp),%xmm0
addss  %xmm3,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x60(%rsp),%xmm0
movss  0x14(%rsp),%xmm1
mulss  0xc0(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x14(%rsp)
movaps 0x20(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movss  0xbdb(%rip),%xmm0
movss  0x8(%rsp),%xmm3
mulss  %xmm3,%xmm0
addss  0xbcd(%rip),%xmm0
movss  0xb9d(%rip),%xmm1
movss  0x4(%rsp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
movaps %xmm3,%xmm1
mulss  0xbad(%rip),%xmm1
mulss  %xmm2,%xmm1
mulss  0x80(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rsp),%xmm0
mulss  0x50(%rsp),%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x20(%rsp),%xmm0
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x20(%rsp)
movaps 0x70(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movss  0xb42(%rip),%xmm0
mulss  0x40(%rsp),%xmm0
addss  0xb50(%rip),%xmm0
movaps %xmm0,%xmm2
movss  0xb19(%rip),%xmm0
movss  0x4(%rsp),%xmm1
mulss  %xmm1,%xmm0
addss  %xmm2,%xmm0
movss  0xb2b(%rip),%xmm2
mulss  0x30(%rsp),%xmm2
mulss  %xmm1,%xmm2
mulss  0xc(%rsp),%xmm2
addss  %xmm0,%xmm2
movaps %xmm2,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x70(%rsp),%xmm0
addss  0x20(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1580 <target_y+0x460>
sqrtss %xmm0,%xmm0
jmp    1585 <target_y+0x465>
call   1040 <sqrt@plt>
movaps 0x40(%rsp),%xmm8
movss  0x8(%rsp),%xmm9
movss  0x4(%rsp),%xmm7
movaps 0x30(%rsp),%xmm10
movaps 0x50(%rsp),%xmm12
movss  0x10(%rsp),%xmm13
movss  0x18(%rsp),%xmm14
movss  0xc(%rsp),%xmm15
mulss  %xmm12,%xmm13
movss  0xa8a(%rip),%xmm1
mulss  %xmm7,%xmm1
mulss  %xmm15,%xmm1
movss  0xa75(%rip),%xmm2
mulss  %xmm7,%xmm2
movss  0xa65(%rip),%xmm3
mulss  %xmm7,%xmm3
movss  0xa55(%rip),%xmm4
mulss  %xmm7,%xmm4
movss  0xa5d(%rip),%xmm5
mulss  0xa3d(%rip),%xmm7
addss  0xa6d(%rip),%xmm7
mulss  %xmm8,%xmm5
movss  0xa44(%rip),%xmm6
mulss  %xmm8,%xmm6
addss  %xmm7,%xmm6
movss  0xa43(%rip),%xmm7
mulss  %xmm9,%xmm7
addss  %xmm6,%xmm7
movss  0xa3a(%rip),%xmm6
mulss  %xmm10,%xmm6
addss  %xmm7,%xmm6
mulss  0xa30(%rip),%xmm15
addss  %xmm6,%xmm15
mulss  0xa26(%rip),%xmm14
addss  %xmm15,%xmm14
mulss  %xmm10,%xmm5
addss  %xmm14,%xmm5
mulss  0xa12(%rip),%xmm12
addss  %xmm5,%xmm12
mulss  %xmm9,%xmm4
addss  %xmm12,%xmm4
mulss  %xmm10,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm8,%xmm2
addss  %xmm3,%xmm2
mulss  0x80(%rsp),%xmm1
addss  %xmm2,%xmm1
mulss  %xmm9,%xmm13
addss  %xmm1,%xmm13
movss  %xmm0,(%rbx)
movaps %xmm13,%xmm0
add    $0x130,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@__const.target_y.coeff = [15 x float] [float 0xBF82D3FB00000000, float 0xC0161F10C0000000, float 0xC042DDC360000000, float 0x402228D680000000, float 0x404F83FEC0000000, float 0x3FC62E58C0000000, float 0x3FABAE77E0000000, float 0x3F947DF480000000, float 0xBF8A9421C0000000, float 0xBFC8DA4E80000000, float 0x3F999CA400000000, float 0xBF93EA2020000000, float 0x3F73FBD240000000, float 0xBF63A94320000000, 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 [15 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
%34 = alloca float
%35 = alloca float
store float* %0, float** %4
store float* %1, float** %5
store i32 %2, i32* %6
store i32 14, i32* %7
store float 0x40370201C0000000, float* %8
%36 = bitcast [10 x float]* %9 to i8*
%37 = bitcast i8* %36 to [10 x float]*
%38 = getelementptr inbounds [10 x float], [10 x float]* %37, i32 0, i32 0
store float -1.500000e+01, float* %38
%39 = getelementptr inbounds [10 x float], [10 x float]* %37, i32 0, i32 1
store float -1.500000e+01, float* %39
%40 = getelementptr inbounds [10 x float], [10 x float]* %37, i32 0, i32 2
store float 0xC03200C4A0000000, float* %40
%41 = getelementptr inbounds [10 x float], [10 x float]* %37, i32 0, i32 3
store float 0xC032028F60000000, float* %41
%42 = bitcast [10 x float]* %10 to i8*
%43 = bitcast i8* %42 to [10 x float]*
%44 = getelementptr inbounds [10 x float], [10 x float]* %43, i32 0, i32 0
store float 1.500000e+01, float* %44
%45 = getelementptr inbounds [10 x float], [10 x float]* %43, i32 0, i32 1
store float 1.500000e+01, float* %45
%46 = getelementptr inbounds [10 x float], [10 x float]* %43, i32 0, i32 2
store float 0x4032028F60000000, float* %46
%47 = getelementptr inbounds [10 x float], [10 x float]* %43, i32 0, i32 3
store float 0x4032008320000000, float* %47
%48 = bitcast [10 x float]* %11 to i8*
%49 = bitcast [15 x float]* %12 to i8*
store i32 0, i32* %13
%50 = load i32, i32* %13
%51 = icmp eq i32 %50, 0
br i1 %51, label %52, label %88
52: ; preds = %3
store i32 1, i32* %13
store i32 0, i32* %14
br label %53
53: ; preds = %84, %52
%54 = load i32, i32* %14
%55 = load i32, i32* %6
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %87
57: ; preds = %53
%58 = load i32, i32* %14
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [10 x float], [10 x float]* %9, i64 0, i64 %59
%61 = load float, float* %60
%62 = load i32, i32* %14
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [10 x float], [10 x float]* %10, i64 0, i64 %63
%65 = load float, float* %64
%66 = fcmp oeq float %61, %65
br i1 %66, label %67, label %68
67: ; preds = %57
br label %84
68: ; preds = %57
%69 = load i32, i32* %14
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [10 x float], [10 x float]* %10, i64 0, i64 %70
%72 = load float, float* %71
%73 = load i32, i32* %14
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [10 x float], [10 x float]* %9, i64 0, i64 %74
%76 = load float, float* %75
%77 = fsub float %72, %76
%78 = fpext float %77 to double
%79 = fdiv double 2.000000e+00, %78
%80 = fptrunc double %79 to float
%81 = load i32, i32* %14
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 %82
store float %80, float* %83
br label %84
84: ; preds = %68, %67
%85 = load i32, i32* %14
%86 = add nsw i32 %85, 1
store i32 %86, i32* %14
br label %53
87: ; preds = %53
br label %88
88: ; preds = %87, %3
%89 = load float*, float** %4
%90 = getelementptr inbounds float, float* %89, i64 0
%91 = load float, float* %90
%92 = getelementptr inbounds [10 x float], [10 x float]* %10, i64 0, i64 0
%93 = load float, float* %92
%94 = fsub float %91, %93
%95 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 0
%96 = load float, float* %95
%97 = fmul float %94, %96
%98 = fpext float %97 to double
%99 = fadd double 1.000000e+00, %98
%100 = fptrunc double %99 to float
store float %100, float* %15
%101 = load float*, float** %5
%102 = getelementptr inbounds float, float* %101, i64 0
%103 = load float, float* %102
%104 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 0
%105 = load float, float* %104
%106 = fmul float %103, %105
store float %106, float* %16
%107 = load float*, float** %4
%108 = getelementptr inbounds float, float* %107, i64 1
%109 = load float, float* %108
%110 = getelementptr inbounds [10 x float], [10 x float]* %10, i64 0, i64 1
%111 = load float, float* %110
%112 = fsub float %109, %111
%113 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 1
%114 = load float, float* %113
%115 = fmul float %112, %114
%116 = fpext float %115 to double
%117 = fadd double 1.000000e+00, %116
%118 = fptrunc double %117 to float
store float %118, float* %17
%119 = load float*, float** %5
%120 = getelementptr inbounds float, float* %119, i64 1
%121 = load float, float* %120
%122 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 1
%123 = load float, float* %122
%124 = fmul float %121, %123
store float %124, float* %18
%125 = load float*, float** %4
%126 = getelementptr inbounds float, float* %125, i64 2
%127 = load float, float* %126
%128 = getelementptr inbounds [10 x float], [10 x float]* %10, i64 0, i64 2
%129 = load float, float* %128
%130 = fsub float %127, %129
%131 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 2
%132 = load float, float* %131
%133 = fmul float %130, %132
%134 = fpext float %133 to double
%135 = fadd double 1.000000e+00, %134
%136 = fptrunc double %135 to float
store float %136, float* %19
%137 = load float*, float** %5
%138 = getelementptr inbounds float, float* %137, i64 2
%139 = load float, float* %138
%140 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 2
%141 = load float, float* %140
%142 = fmul float %139, %141
store float %142, float* %20
%143 = load float*, float** %4
%144 = getelementptr inbounds float, float* %143, i64 3
%145 = load float, float* %144
%146 = getelementptr inbounds [10 x float], [10 x float]* %10, i64 0, i64 3
%147 = load float, float* %146
%148 = fsub float %145, %147
%149 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 3
%150 = load float, float* %149
%151 = fmul float %148, %150
%152 = fpext float %151 to double
%153 = fadd double 1.000000e+00, %152
%154 = fptrunc double %153 to float
store float %154, float* %21
%155 = load float*, float** %5
%156 = getelementptr inbounds float, float* %155, i64 3
%157 = load float, float* %156
%158 = getelementptr inbounds [10 x float], [10 x float]* %11, i64 0, i64 3
%159 = load float, float* %158
%160 = fmul float %157, %159
store float %160, float* %22
%161 = load float, float* %15
store float %161, float* %23
%162 = load float, float* %23
%163 = load float, float* %15
%164 = fmul float %162, %163
store float %164, float* %24
%165 = load float, float* %24
%166 = load float, float* %15
%167 = fmul float %165, %166
store float %167, float* %25
%168 = load float, float* %25
%169 = load float, float* %15
%170 = fmul float %168, %169
store float %170, float* %26
%171 = load float, float* %17
store float %171, float* %27
%172 = load float, float* %27
%173 = load float, float* %17
%174 = fmul float %172, %173
store float %174, float* %28
%175 = load float, float* %19
store float %175, float* %29
%176 = load float, float* %29
%177 = load float, float* %19
%178 = fmul float %176, %177
store float %178, float* %30
%179 = load float, float* %21
store float %179, float* %31
%180 = load float, float* %31
%181 = load float, float* %21
%182 = fmul float %180, %181
store float %182, float* %32
%183 = load float, float* %8
%184 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 0
%185 = load float, float* %184
%186 = fadd float %183, %185
%187 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 1
%188 = load float, float* %187
%189 = load float, float* %23
%190 = call float @llvm.fmuladd.f32(float %188, float %189, float %186)
%191 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 2
%192 = load float, float* %191
%193 = load float, float* %27
%194 = call float @llvm.fmuladd.f32(float %192, float %193, float %190)
%195 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 3
%196 = load float, float* %195
%197 = load float, float* %29
%198 = call float @llvm.fmuladd.f32(float %196, float %197, float %194)
%199 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 4
%200 = load float, float* %199
%201 = load float, float* %31
%202 = call float @llvm.fmuladd.f32(float %200, float %201, float %198)
%203 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 5
%204 = load float, float* %203
%205 = load float, float* %30
%206 = call float @llvm.fmuladd.f32(float %204, float %205, float %202)
%207 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 6
%208 = load float, float* %207
%209 = load float, float* %24
%210 = call float @llvm.fmuladd.f32(float %208, float %209, float %206)
%211 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 7
%212 = load float, float* %211
%213 = load float, float* %27
%214 = fmul float %212, %213
%215 = load float, float* %31
%216 = call float @llvm.fmuladd.f32(float %214, float %215, float %210)
store float %216, float* %33
%217 = load float, float* %33
%218 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 8
%219 = load float, float* %218
%220 = load float, float* %28
%221 = call float @llvm.fmuladd.f32(float %219, float %220, float %217)
%222 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 9
%223 = load float, float* %222
%224 = load float, float* %23
%225 = fmul float %223, %224
%226 = load float, float* %29
%227 = call float @llvm.fmuladd.f32(float %225, float %226, float %221)
%228 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 10
%229 = load float, float* %228
%230 = load float, float* %23
%231 = fmul float %229, %230
%232 = load float, float* %31
%233 = call float @llvm.fmuladd.f32(float %231, float %232, float %227)
%234 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 11
%235 = load float, float* %234
%236 = load float, float* %23
%237 = fmul float %235, %236
%238 = load float, float* %27
%239 = call float @llvm.fmuladd.f32(float %237, float %238, float %233)
%240 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 12
%241 = load float, float* %240
%242 = load float, float* %23
%243 = fmul float %241, %242
%244 = load float, float* %30
%245 = fmul float %243, %244
%246 = load float, float* %32
%247 = call float @llvm.fmuladd.f32(float %245, float %246, float %239)
%248 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 13
%249 = load float, float* %248
%250 = load float, float* %26
%251 = fmul float %249, %250
%252 = load float, float* %28
%253 = fmul float %251, %252
%254 = load float, float* %29
%255 = call float @llvm.fmuladd.f32(float %253, float %254, float %247)
store float %255, float* %33
%256 = load float, float* %16
%257 = fadd float 0.000000e+00, %256
%258 = load float, float* %18
%259 = fadd float %257, %258
%260 = load float, float* %20
%261 = fadd float %259, %260
%262 = load float, float* %22
%263 = fadd float %261, %262
store float %263, float* %34
%264 = load float, float* %34
%265 = fcmp oeq float %264, 0.000000e+00
br i1 %265, label %266, label %267
266: ; preds = %88
br label %396
267: ; preds = %88
%268 = load float, float* %16
%269 = load float, float* %16
%270 = fmul float %268, %269
%271 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 1
%272 = load float, float* %271
%273 = fadd float 0.000000e+00, %272
%274 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 6
%275 = load float, float* %274
%276 = fmul float 2.000000e+00, %275
%277 = load float, float* %23
%278 = call float @llvm.fmuladd.f32(float %276, float %277, float %273)
%279 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 9
%280 = load float, float* %279
%281 = load float, float* %29
%282 = call float @llvm.fmuladd.f32(float %280, float %281, float %278)
%283 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 10
%284 = load float, float* %283
%285 = load float, float* %31
%286 = call float @llvm.fmuladd.f32(float %284, float %285, float %282)
%287 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 11
%288 = load float, float* %287
%289 = load float, float* %27
%290 = call float @llvm.fmuladd.f32(float %288, float %289, float %286)
%291 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 12
%292 = load float, float* %291
%293 = load float, float* %30
%294 = fmul float %292, %293
%295 = load float, float* %32
%296 = call float @llvm.fmuladd.f32(float %294, float %295, float %290)
%297 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 13
%298 = load float, float* %297
%299 = fmul float 4.000000e+00, %298
%300 = load float, float* %25
%301 = fmul float %299, %300
%302 = load float, float* %28
%303 = fmul float %301, %302
%304 = load float, float* %29
%305 = call float @llvm.fmuladd.f32(float %303, float %304, float %296)
%306 = call float @pow(float %305, i32 2)
%307 = load float, float* %18
%308 = load float, float* %18
%309 = fmul float %307, %308
%310 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 2
%311 = load float, float* %310
%312 = fadd float 0.000000e+00, %311
%313 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 7
%314 = load float, float* %313
%315 = load float, float* %31
%316 = call float @llvm.fmuladd.f32(float %314, float %315, float %312)
%317 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 8
%318 = load float, float* %317
%319 = fmul float 2.000000e+00, %318
%320 = load float, float* %27
%321 = call float @llvm.fmuladd.f32(float %319, float %320, float %316)
%322 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 11
%323 = load float, float* %322
%324 = load float, float* %23
%325 = call float @llvm.fmuladd.f32(float %323, float %324, float %321)
%326 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 13
%327 = load float, float* %326
%328 = fmul float 2.000000e+00, %327
%329 = load float, float* %27
%330 = fmul float %328, %329
%331 = load float, float* %26
%332 = fmul float %330, %331
%333 = load float, float* %29
%334 = call float @llvm.fmuladd.f32(float %332, float %333, float %325)
%335 = call float @pow(float %334, i32 2)
%336 = fmul float %309, %335
%337 = call float @llvm.fmuladd.f32(float %270, float %306, float %336)
%338 = load float, float* %20
%339 = load float, float* %20
%340 = fmul float %338, %339
%341 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 3
%342 = load float, float* %341
%343 = fadd float 0.000000e+00, %342
%344 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 5
%345 = load float, float* %344
%346 = fmul float 2.000000e+00, %345
%347 = load float, float* %29
%348 = call float @llvm.fmuladd.f32(float %346, float %347, float %343)
%349 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 9
%350 = load float, float* %349
%351 = load float, float* %23
%352 = call float @llvm.fmuladd.f32(float %350, float %351, float %348)
%353 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 12
%354 = load float, float* %353
%355 = fmul float 2.000000e+00, %354
%356 = load float, float* %29
%357 = fmul float %355, %356
%358 = load float, float* %23
%359 = fmul float %357, %358
%360 = load float, float* %32
%361 = call float @llvm.fmuladd.f32(float %359, float %360, float %352)
%362 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 13
%363 = load float, float* %362
%364 = load float, float* %26
%365 = fmul float %363, %364
%366 = load float, float* %28
%367 = call float @llvm.fmuladd.f32(float %365, float %366, float %361)
%368 = call float @pow(float %367, i32 2)
%369 = call float @llvm.fmuladd.f32(float %340, float %368, float %337)
%370 = load float, float* %22
%371 = load float, float* %22
%372 = fmul float %370, %371
%373 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 4
%374 = load float, float* %373
%375 = fadd float 0.000000e+00, %374
%376 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 7
%377 = load float, float* %376
%378 = load float, float* %27
%379 = call float @llvm.fmuladd.f32(float %377, float %378, float %375)
%380 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 10
%381 = load float, float* %380
%382 = load float, float* %23
%383 = call float @llvm.fmuladd.f32(float %381, float %382, float %379)
%384 = getelementptr inbounds [15 x float], [15 x float]* %12, i64 0, i64 12
%385 = load float, float* %384
%386 = fmul float 2.000000e+00, %385
%387 = load float, float* %31
%388 = fmul float %386, %387
%389 = load float, float* %23
%390 = fmul float %388, %389
%391 = load float, float* %30
%392 = call float @llvm.fmuladd.f32(float %390, float %391, float %383)
%393 = call float @pow(float %392, i32 2)
%394 = call float @llvm.fmuladd.f32(float %372, float %393, float %369)
%395 = call float @sqrt(float %394)
br label %396
396: ; preds = %267, %266
%397 = phi float [ 0.000000e+00, %266 ], [ %395, %267 ]
store float %397, float* %35
%398 = load float, float* %35
%399 = load float*, float** %5
%400 = getelementptr inbounds float, float* %399, i64 0
store float %398, float* %400
%401 = load float, float* %33
ret float %401
}

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 0xC03200C4A0000000, float 0xC032028F60000000>, <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 0x4032028F60000000, float 0x4032008320000000>, <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, 0xC032028F60000000
%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, 0xC032008320000000
%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 %49, %49
%76 = fmul float %49, %75
%77 = fmul float %49, %76
%78 = fmul float %55, %55
%79 = fmul float %64, %64
%80 = fmul float %71, %71
%81 = fmul float %77, 0xBF63A94320000000
%82 = extractelement <2 x float> %58, i64 0
%83 = fadd float %82, 0.000000e+00
%84 = extractelement <2 x float> %58, i64 1
%85 = fadd float %83, %84
%86 = extractelement <2 x float> %74, i64 0
%87 = fadd float %85, %86
%88 = extractelement <2 x float> %74, i64 1
%89 = fadd float %87, %88
%90 = fcmp oeq float %89, 0.000000e+00
br i1 %90, label %133, label %91
91: ; preds = %42
%92 = fmul <2 x float> %58, %58
%93 = extractelement <2 x float> %92, i64 0
%94 = tail call float @llvm.fmuladd.f32(float %49, float 0x3FBBAE77E0000000, float 0xC0161F10C0000000)
%95 = tail call float @llvm.fmuladd.f32(float %64, float 0xBFC8DA4E80000000, float %94)
%96 = tail call float @llvm.fmuladd.f32(float %71, float 0x3F999CA400000000, float %95)
%97 = tail call float @llvm.fmuladd.f32(float %55, float 0xBF93EA2020000000, float %96)
%98 = fmul float %79, 0x3F73FBD240000000
%99 = tail call float @llvm.fmuladd.f32(float %98, float %80, float %97)
%100 = fmul float %76, 0xBF83A94320000000
%101 = fmul float %100, %78
%102 = tail call float @llvm.fmuladd.f32(float %101, float %64, float %99)
%103 = tail call float @pow(float %102, i32 2)
%104 = fmul float %84, %84
%105 = tail call float @llvm.fmuladd.f32(float %71, float 0x3F947DF480000000, float 0xC042DDC360000000)
%106 = tail call float @llvm.fmuladd.f32(float %55, float 0xBF9A9421C0000000, float %105)
%107 = tail call float @llvm.fmuladd.f32(float %49, float 0xBF93EA2020000000, float %106)
%108 = fmul float %55, 0xBF73A94320000000
%109 = fmul float %77, %108
%110 = tail call float @llvm.fmuladd.f32(float %109, float %64, float %107)
%111 = tail call float @pow(float %110, i32 2)
%112 = fmul float %104, %111
%113 = tail call float @llvm.fmuladd.f32(float %93, float %103, float %112)
%114 = fmul <2 x float> %74, %74
%115 = extractelement <2 x float> %114, i64 0
%116 = tail call float @llvm.fmuladd.f32(float %64, float 0x3FD62E58C0000000, float 0x402228D680000000)
%117 = tail call float @llvm.fmuladd.f32(float %49, float 0xBFC8DA4E80000000, float %116)
%118 = fmul float %64, 0x3F83FBD240000000
%119 = fmul float %49, %118
%120 = tail call float @llvm.fmuladd.f32(float %119, float %80, float %117)
%121 = tail call float @llvm.fmuladd.f32(float %81, float %78, float %120)
%122 = tail call float @pow(float %121, i32 2)
%123 = tail call float @llvm.fmuladd.f32(float %115, float %122, float %113)
%124 = fmul float %88, %88
%125 = tail call float @llvm.fmuladd.f32(float %55, float 0x3F947DF480000000, float 0x404F83FEC0000000)
%126 = tail call float @llvm.fmuladd.f32(float %49, float 0x3F999CA400000000, float %125)
%127 = fmul float %71, 0x3F83FBD240000000
%128 = fmul float %49, %127
%129 = tail call float @llvm.fmuladd.f32(float %128, float %79, float %126)
%130 = tail call float @pow(float %129, i32 2)
%131 = tail call float @llvm.fmuladd.f32(float %124, float %130, float %123)
%132 = tail call float @sqrt(float %131)
br label %133
133: ; preds = %42, %91
%134 = phi float [ %132, %91 ], [ 0.000000e+00, %42 ]
%135 = fmul float %81, %78
%136 = fmul float %49, 0x3F73FBD240000000
%137 = fmul float %136, %79
%138 = fmul float %49, 0xBF93EA2020000000
%139 = fmul float %49, 0x3F999CA400000000
%140 = fmul float %49, 0xBFC8DA4E80000000
%141 = fmul float %55, 0x3F947DF480000000
%142 = tail call float @llvm.fmuladd.f32(float %49, float 0xC0161F10C0000000, float 0x4036FFA740000000)
%143 = tail call float @llvm.fmuladd.f32(float %55, float 0xC042DDC360000000, float %142)
%144 = tail call float @llvm.fmuladd.f32(float %64, float 0x402228D680000000, float %143)
%145 = tail call float @llvm.fmuladd.f32(float %71, float 0x404F83FEC0000000, float %144)
%146 = tail call float @llvm.fmuladd.f32(float %79, float 0x3FC62E58C0000000, float %145)
%147 = tail call float @llvm.fmuladd.f32(float %75, float 0x3FABAE77E0000000, float %146)
%148 = tail call float @llvm.fmuladd.f32(float %141, float %71, float %147)
%149 = tail call float @llvm.fmuladd.f32(float %78, float 0xBF8A9421C0000000, float %148)
%150 = tail call float @llvm.fmuladd.f32(float %140, float %64, float %149)
%151 = tail call float @llvm.fmuladd.f32(float %139, float %71, float %150)
%152 = tail call float @llvm.fmuladd.f32(float %138, float %55, float %151)
%153 = tail call float @llvm.fmuladd.f32(float %137, float %80, float %152)
%154 = tail call float @llvm.fmuladd.f32(float %135, float %64, float %153)
store float %134, float* %1
ret float %154
}