#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 = 7;
  float avdat = -0.1369434E+01;
  float xmin[10] = {-0.15000E+02, -0.15000E+02, -0.18005E+02, -0.18008E+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.18003E+02, 0.18001E+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[8] = {
      -0.46303957E-02, -0.37682531E+01, -0.37984043E+02, 0.61871805E+01,
      0.63466038E+02,  -0.45517422E-01, 0.66252351E-01,  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 x21 = x2;
  float x31 = x3;
  float x32 = x31 * x3;
  float x41 = x4;
  float v_target_y = avdat + coeff[0] + coeff[1] * x11 + coeff[2] * x21 +
                     coeff[3] * x31 + coeff[4] * x41 + coeff[5] * x11 * x31 +
                     coeff[6] * x32;
  float dxall = 0 + dx1 + dx2 + dx3 + dx4;
  float dv_target_y =
      dxall == 0
          ? 0
          : sqrt(
                +dx1 * dx1 * pow(0 + coeff[1] + coeff[5] * x31, 2) +
                dx2 * dx2 * pow(0 + coeff[2], 2) +
                dx3 * dx3 *
                    pow(0 + coeff[3] + coeff[5] * x11 + 2 * coeff[6] * x31, 2) +
                dx4 * dx4 * pow(0 + coeff[4], 2));
  dx[0] = dv_target_y;
  return v_target_y;
}


x86 assembly (clang, -O0):
<target_y>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x7,-0x18(%rbp)
movss  0xec3(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
movss  0xea2(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0xe95(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xe84(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xe73(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
movss  0xe52(%rip),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  0xe45(%rip),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  0xe34(%rip),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  0xe23(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
mov    0xe34(%rip),%rax
mov    %rax,-0xd0(%rbp)
mov    0xe2e(%rip),%rax
mov    %rax,-0xc8(%rbp)
mov    0xe28(%rip),%rax
mov    %rax,-0xc0(%rbp)
mov    0xe22(%rip),%rax
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0xd4(%rbp)
cmpl   $0x0,-0xd4(%rbp)
jne    12e8 <target_y+0x1b8>
movl   $0x1,-0xd4(%rbp)
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12e3 <target_y+0x1b3>
movslq -0xd8(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0xd8(%rbp),%rax
ucomiss -0x80(%rbp,%rax,4),%xmm0
jne    1291 <target_y+0x161>
jp     1291 <target_y+0x161>
jmp    12cf <target_y+0x19f>
movslq -0xd8(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm0
movslq -0xd8(%rbp),%rax
subss  -0x50(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd71(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0xd8(%rbp),%rax
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1258 <target_y+0x128>
jmp    12e8 <target_y+0x1b8>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x80(%rbp),%xmm0
mulss  -0xb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xd17(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x7c(%rbp),%xmm0
mulss  -0xac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xccd(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  -0x78(%rbp),%xmm0
mulss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc82(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  -0x74(%rbp),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc37(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0x100(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
mulss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
addss  -0xd0(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
movss  -0xfc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc8(%rbp),%xmm0
ff
movss  -0x100(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc4(%rbp),%xmm1
ff
movss  -0x104(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc0(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xbc(%rbp),%xmm1
ff
mulss  -0xfc(%rbp),%xmm1
ff
movss  -0x104(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xb8(%rbp),%xmm0
ff
movss  -0x108(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xe0(%rbp),%xmm0
ff
addss  -0xe8(%rbp),%xmm0
ff
addss  -0xf0(%rbp),%xmm0
ff
addss  -0xf8(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    156c <target_y+0x43c>
jp     156c <target_y+0x43c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
jmp    16f2 <target_y+0x5c2>
movss  -0xe0(%rbp),%xmm0
ff
mulss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0x130(%rbp)
ff
xorps  %xmm1,%xmm1
addss  -0xcc(%rbp),%xmm1
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
movss  %xmm0,-0x134(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
mulss  -0xe8(%rbp),%xmm0
ff
movss  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xc8(%rbp),%xmm0
ff
mov    $0x2,%edi
call   1040 <pow@plt>
movss  -0x138(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movss  -0x130(%rbp),%xmm0
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0xf0(%rbp),%xmm0
ff
mulss  -0xf0(%rbp),%xmm0
ff
movss  %xmm0,-0x128(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xc4(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
movss  -0xfc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x9c4(%rip),%xmm0
mulss  -0xb8(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
movss  -0x12c(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x128(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x124(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
mulss  -0xf8(%rbp),%xmm0
ff
movss  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xc0(%rbp),%xmm0
ff
mov    $0x2,%edi
call   1040 <pow@plt>
movss  -0x124(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x120(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1050 <sqrt@plt>
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0x11c(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x110(%rbp),%xmm0
ff
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<target_y>:
push   %rbx
sub    $0x110,%rsp
mov    %rsi,%rbx
xorps  %xmm3,%xmm3
movaps %xmm3,0xf0(%rsp)
movq   $0x0,0x100(%rsp)
movaps 0xeb7(%rip),%xmm0
movaps %xmm0,0xe0(%rsp)
movaps %xmm3,0xc0(%rsp)
movq   $0x0,0xd0(%rsp)
movaps 0xea4(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps %xmm3,0x80(%rsp)
movaps %xmm3,0x70(%rsp)
movq   $0x0,0x90(%rsp)
xorps  %xmm4,%xmm4
test   %edx,%edx
jle    1201 <target_y+0xe1>
mov    %edx,%eax
add    $0xffffffffffffffff,%rax
movss  0xe7e(%rip),%xmm2
movss  0xe7a(%rip),%xmm1
xor    %ecx,%ecx
movss  0xe74(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
ucomiss %xmm1,%xmm2
jne    11c7 <target_y+0xa7>
jnp    11d8 <target_y+0xb8>
subss  %xmm2,%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x70(%rsp,%rcx,4)
cmp    %rcx,%rax
je     11f5 <target_y+0xd5>
movss  0xe4(%rsp,%rcx,4),%xmm2
movss  0xb4(%rsp,%rcx,4),%xmm1
add    $0x1,%rcx
jmp    11c0 <target_y+0xa0>
movsd  0x70(%rsp),%xmm4
movsd  0x78(%rsp),%xmm3
movss  (%rdi),%xmm5
movss  0x4(%rdi),%xmm8
addss  0xe0d(%rip),%xmm5
mulss  %xmm4,%xmm5
movss  0xe0c(%rip),%xmm9
addss  %xmm9,%xmm5
movsd  (%rbx),%xmm2
movsd  0x8(%rbx),%xmm10
mulps  %xmm4,%xmm2
movaps %xmm2,%xmm12
shufps $0x55,%xmm2,%xmm12
movss  0x8(%rdi),%xmm6
addss  0xde8(%rip),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm9,%xmm6
movss  0xc(%rdi),%xmm7
mulps  %xmm3,%xmm10
movaps %xmm10,%xmm11
shufps $0x55,%xmm10,%xmm11
xorps  %xmm0,%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
addss  %xmm12,%xmm1
addss  %xmm10,%xmm1
addss  %xmm11,%xmm1
ucomiss %xmm0,%xmm1
jne    1287 <target_y+0x167>
jnp    13ea <target_y+0x2ca>
movss  %xmm7,0x18(%rsp)
movss  %xmm8,0x1c(%rsp)
movaps %xmm4,0x50(%rsp)
movaps %xmm3,0x60(%rsp)
mulss  %xmm2,%xmm2
movaps %xmm2,0xa0(%rsp)
movaps %xmm6,%xmm0
mulss  0xd7f(%rip),%xmm0
addss  0xd7b(%rip),%xmm0
mov    $0x2,%edi
movss  %xmm5,0x10(%rsp)
movss  %xmm6,0xc(%rsp)
movaps %xmm10,0x20(%rsp)
movaps %xmm11,0x40(%rsp)
movaps %xmm12,0x30(%rsp)
call   1030 <pow@plt>
movss  %xmm0,0x14(%rsp)
movaps 0x30(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movss  0xd3b(%rip),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x30(%rsp),%xmm0
movss  0x14(%rsp),%xmm1
mulss  0xa0(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x14(%rsp)
movss  0xd02(%rip),%xmm0
mulss  0x10(%rsp),%xmm0
addss  0xd00(%rip),%xmm0
movaps %xmm0,%xmm1
movaps 0x20(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movss  0xceb(%rip),%xmm0
mulss  0xc(%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 0x40(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x40(%rsp)
movss  0xcb3(%rip),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x40(%rsp),%xmm0
addss  0x20(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     13b9 <target_y+0x299>
sqrtss %xmm0,%xmm0
jmp    13be <target_y+0x29e>
call   1040 <sqrt@plt>
movaps 0x60(%rsp),%xmm3
movaps 0x50(%rsp),%xmm4
movss  0x10(%rsp),%xmm5
movss  0xc(%rsp),%xmm6
movss  0xc4f(%rip),%xmm9
movss  0x1c(%rsp),%xmm8
movss  0x18(%rsp),%xmm7
movaps %xmm6,%xmm1
mulss  %xmm6,%xmm1
movss  0xc3b(%rip),%xmm2
addss  0xc4b(%rip),%xmm7
mulss  %xmm5,%xmm2
shufps $0x55,%xmm3,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm9,%xmm3
addss  0xc05(%rip),%xmm8
shufps $0x55,%xmm4,%xmm4
mulss  %xmm8,%xmm4
mulss  0xc0c(%rip),%xmm5
addss  0xc1c(%rip),%xmm5
addss  %xmm9,%xmm4
mulss  0xbfb(%rip),%xmm4
addss  %xmm5,%xmm4
mulss  %xmm6,%xmm2
mulss  0xbef(%rip),%xmm6
addss  %xmm4,%xmm6
mulss  0xbeb(%rip),%xmm3
addss  %xmm6,%xmm3
addss  %xmm2,%xmm3
mulss  0xbe7(%rip),%xmm1
addss  %xmm3,%xmm1
movss  %xmm0,(%rbx)
movaps %xmm1,%xmm0
add    $0x110,%rsp
pop    %rbx
ret

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

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 0xC0320147A0000000, float 0xC032020C40000000>, <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 0x403200C4A0000000, float 0x4032004180000000>, <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 = bitcast float* %1 to <2 x float>*
%53 = load <2 x float>, <2 x float>* %52
%54 = fmul <2 x float> %44, %53
%55 = getelementptr inbounds float, float* %0, i64 2
%56 = load float, float* %55
%57 = fadd float %56, 0xC03200C4A0000000
%58 = extractelement <2 x float> %43, i64 0
%59 = fmul float %57, %58
%60 = fadd float %59, 1.000000e+00
%61 = getelementptr inbounds float, float* %1, i64 2
%62 = getelementptr inbounds float, float* %0, i64 3
%63 = load float, float* %62
%64 = bitcast float* %61 to <2 x float>*
%65 = load <2 x float>, <2 x float>* %64
%66 = fmul <2 x float> %43, %65
%67 = extractelement <2 x float> %54, i64 0
%68 = fadd float %67, 0.000000e+00
%69 = extractelement <2 x float> %54, i64 1
%70 = fadd float %68, %69
%71 = extractelement <2 x float> %66, i64 0
%72 = fadd float %70, %71
%73 = extractelement <2 x float> %66, i64 1
%74 = fadd float %72, %73
%75 = fcmp oeq float %74, 0.000000e+00
br i1 %75, label %95, label %76
76: ; preds = %42
%77 = fmul <2 x float> %54, %54
%78 = extractelement <2 x float> %77, i64 0
%79 = tail call float @llvm.fmuladd.f32(float %60, float 0xBFA74E0F40000000, float 0xC00E2561E0000000)
%80 = tail call float @pow(float %79, i32 2)
%81 = fmul float %69, %69
%82 = tail call float @pow(float 0xC042FDF520000000, i32 2)
%83 = fmul float %81, %82
%84 = tail call float @llvm.fmuladd.f32(float %78, float %80, float %83)
%85 = fmul <2 x float> %66, %66
%86 = extractelement <2 x float> %85, i64 0
%87 = tail call float @llvm.fmuladd.f32(float %49, float 0xBFA74E0F40000000, float 0x4018BFAC40000000)
%88 = tail call float @llvm.fmuladd.f32(float %60, float 0x3FC0F5EA00000000, float %87)
%89 = tail call float @pow(float %88, i32 2)
%90 = tail call float @llvm.fmuladd.f32(float %86, float %89, float %84)
%91 = fmul float %73, %73
%92 = tail call float @pow(float 0x404FBBA720000000, i32 2)
%93 = tail call float @llvm.fmuladd.f32(float %91, float %92, float %90)
%94 = tail call float @sqrt(float %93)
br label %95
95: ; preds = %42, %76
%96 = phi float [ %94, %76 ], [ 0.000000e+00, %42 ]
%97 = fmul float %60, %60
%98 = fmul float %49, 0xBFA74E0F40000000
%99 = fadd float %63, 0xC032004180000000
%100 = extractelement <2 x float> %43, i64 1
%101 = fmul float %99, %100
%102 = fadd float %101, 1.000000e+00
%103 = fadd float %51, -1.500000e+01
%104 = extractelement <2 x float> %44, i64 1
%105 = fmul float %103, %104
%106 = fadd float %105, 1.000000e+00
%107 = tail call float @llvm.fmuladd.f32(float %49, float 0xC00E2561E0000000, float 0xBFF5FC2B00000000)
%108 = tail call float @llvm.fmuladd.f32(float %106, float 0xC042FDF520000000, float %107)
%109 = tail call float @llvm.fmuladd.f32(float %60, float 0x4018BFAC40000000, float %108)
%110 = tail call float @llvm.fmuladd.f32(float %102, float 0x404FBBA720000000, float %109)
%111 = tail call float @llvm.fmuladd.f32(float %98, float %60, float %110)
%112 = tail call float @llvm.fmuladd.f32(float %97, float 0x3FB0F5EA00000000, float %111)
store float %96, float* %1
ret float %112
}