#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_x(float *x, float *dx, int m) {
  int ncoeff = 12;
  float avdat = 0.1237288E+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[13] = {-0.64973772E-03,
                     -0.37926899E+02,
                     0.37612317E+01,
                     0.63399105E+02,
                     -0.61777749E+01,
                     -0.36704674E-01,
                     0.55649925E-01,
                     0.66078395E-01,
                     -0.10121660E+00,
                     -0.39459579E-02,
                     0.58683706E-02,
                     -0.55616377E-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 v_target_x = avdat + coeff[0] + coeff[1] * x11 + coeff[2] * x21 +
                     coeff[3] * x31 + coeff[4] * x41 + coeff[5] * x11 * x21 +
                     coeff[6] * x11 * x41 + coeff[7] * x21 * x31;
  v_target_x = v_target_x + coeff[8] * x31 * x41 + coeff[9] * x21 * x32 * x41 +
               coeff[10] * x12 * x22 + coeff[11] * x12 * x21 * x41;
  float dxall = 0 + dx1 + dx2 + dx3 + dx4;
  float dv_target_x =
      dxall == 0
          ? 0
          : sqrt(+dx1 * dx1 *
                     pow(0 + coeff[1] + coeff[5] * x21 + coeff[6] * x41 +
                             2 * coeff[10] * x11 * x22 +
                             2 * coeff[11] * x11 * x21 * x41,
                         2) +
                 dx2 * dx2 *
                     pow(0 + coeff[2] + coeff[5] * x11 + coeff[7] * x31 +
                             coeff[9] * x32 * x41 + 2 * coeff[10] * x21 * x12 +
                             coeff[11] * x12 * x41,
                         2) +
                 dx3 * dx3 *
                     pow(0 + coeff[3] + coeff[7] * x21 + coeff[8] * x41 +
                             2 * coeff[9] * x31 * x21 * x41,
                         2) +
                 dx4 * dx4 *
                     pow(0 + coeff[4] + coeff[6] * x11 + coeff[8] * x31 +
                             coeff[9] * x21 * x32 + coeff[11] * x12 * x21,
                         2));
  dx[0] = dv_target_x;
  return v_target_x;
}


x86 assembly (clang, -O0):
<target_x>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0xc,-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    0xe1d(%rip),%rsi
mov    $0x34,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0xf4(%rbp)
cmpl   $0x0,-0xf4(%rbp)
jne    12d8 <target_x+0x198>
movl   $0x1,-0xf4(%rbp)
movl   $0x0,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d3 <target_x+0x193>
movslq -0xf8(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0xf8(%rbp),%rax
ucomiss -0x80(%rbp,%rax,4),%xmm0
jne    1281 <target_x+0x141>
jp     1281 <target_x+0x141>
jmp    12bf <target_x+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  0xd81(%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_x+0x108>
jmp    12d8 <target_x+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,-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  0xcdd(%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  0xc92(%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  0xc47(%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  -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  -0x10c(%rbp),%xmm0
ff
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x12c(%rbp),%xmm0
ff
mulss  -0x10c(%rbp),%xmm0
ff
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%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  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xe0(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xdc(%rbp),%xmm0
ff
mulss  -0x11c(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xd8(%rbp),%xmm1
ff
mulss  -0x11c(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0x124(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x138(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
mulss  -0x12c(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0x124(%rbp),%xmm0
ff
mulss  -0x130(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xc8(%rbp),%xmm1
ff
mulss  -0x120(%rbp),%xmm1
ff
movss  -0x128(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
mulss  -0x120(%rbp),%xmm0
ff
mulss  -0x124(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x138(%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,-0x13c(%rbp)
ff
movss  -0x13c(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1654 <target_x+0x514>
jp     1654 <target_x+0x514>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
jmp    197a <target_x+0x83a>
movss  -0x100(%rbp),%xmm0
ff
mulss  -0x100(%rbp),%xmm0
ff
movss  %xmm0,-0x158(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xec(%rbp),%xmm0
ff
movss  -0xdc(%rbp),%xmm1
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd8(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x96d(%rip),%xmm1
mulss  -0xc8(%rbp),%xmm1
ff
mulss  -0x11c(%rbp),%xmm1
ff
movss  -0x128(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x945(%rip),%xmm0
mulss  -0xc4(%rbp),%xmm0
ff
mulss  -0x11c(%rbp),%xmm0
ff
mulss  -0x124(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  %xmm0,-0x15c(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
mulss  -0x108(%rbp),%xmm0
ff
movss  %xmm0,-0x160(%rbp)
ff
xorps  %xmm1,%xmm1
addss  -0xe8(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xd4(%rbp),%xmm1
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0x130(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x890(%rip),%xmm1
mulss  -0xc8(%rbp),%xmm1
ff
mulss  -0x124(%rbp),%xmm1
ff
movss  -0x120(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
mulss  -0x120(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x160(%rbp),%xmm1
ff
movss  -0x15c(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movss  -0x158(%rbp),%xmm0
ff
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x154(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
mulss  -0x110(%rbp),%xmm0
ff
movss  %xmm0,-0x150(%rbp)
ff
xorps  %xmm1,%xmm1
addss  -0xe4(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xd0(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x7bc(%rip),%xmm0
mulss  -0xcc(%rbp),%xmm0
ff
mulss  -0x12c(%rbp),%xmm0
ff
mulss  -0x124(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x154(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x150(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
movss  %xmm0,-0x148(%rbp)
ff
xorps  %xmm0,%xmm0
addss  -0xe0(%rbp),%xmm0
ff
movss  -0xd8(%rbp),%xmm1
ff
movss  -0x11c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xcc(%rbp),%xmm1
ff
mulss  -0x124(%rbp),%xmm1
ff
movss  -0x130(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
mulss  -0x120(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movss  -0x14c(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x148(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
movss  %xmm0,-0x140(%rbp)
ff
movss  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x138(%rbp),%xmm0
ff
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<target_x>:
push   %rbx
sub    $0x120,%rsp
mov    %rsi,%rbx
xorps  %xmm0,%xmm0
movaps %xmm0,0x100(%rsp)
movq   $0x0,0x110(%rsp)
movaps 0xeb7(%rip),%xmm1
movaps %xmm1,0xf0(%rsp)
movaps %xmm0,0xd0(%rsp)
movq   $0x0,0xe0(%rsp)
movaps 0xea4(%rip),%xmm1
movaps %xmm1,0xc0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movq   $0x0,0xa0(%rsp)
xorps  %xmm1,%xmm1
test   %edx,%edx
jle    120a <target_x+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_x+0xa7>
jnp    11db <target_x+0xbb>
subss  %xmm2,%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x80(%rsp,%rcx,4)
cmp    %rcx,%rax
je     11f8 <target_x+0xd8>
movss  0xf4(%rsp,%rcx,4),%xmm2
movss  0xc4(%rsp,%rcx,4),%xmm1
add    $0x1,%rcx
jmp    11c0 <target_x+0xa0>
movsd  0x80(%rsp),%xmm1
movsd  0x88(%rsp),%xmm0
movss  0xe0e(%rip),%xmm2
movss  (%rdi),%xmm5
addss  %xmm2,%xmm5
mulss  %xmm1,%xmm5
movss  0xe06(%rip),%xmm3
addss  %xmm3,%xmm5
addss  0x4(%rdi),%xmm2
movaps %xmm1,%xmm7
shufps $0x55,%xmm1,%xmm7
mulss  %xmm2,%xmm7
addss  %xmm3,%xmm7
movsd  (%rbx),%xmm4
movsd  0x8(%rbx),%xmm13
mulps  %xmm1,%xmm4
movaps %xmm4,%xmm14
shufps $0x55,%xmm4,%xmm14
movss  0x8(%rdi),%xmm6
addss  0xdcf(%rip),%xmm6
movss  0xc(%rdi),%xmm1
mulss  %xmm0,%xmm6
addss  0xdc2(%rip),%xmm1
addss  %xmm3,%xmm6
movaps %xmm0,%xmm9
shufps $0x55,%xmm0,%xmm9
mulss  %xmm1,%xmm9
addss  %xmm3,%xmm9
mulps  %xmm0,%xmm13
movaps %xmm13,%xmm3
shufps $0x55,%xmm13,%xmm3
movaps %xmm5,%xmm8
mulss  %xmm5,%xmm8
movaps %xmm7,%xmm11
mulss  %xmm7,%xmm11
movaps %xmm6,%xmm2
mulss  %xmm6,%xmm2
movss  0xd80(%rip),%xmm12
mulss  %xmm7,%xmm12
movss  0xd76(%rip),%xmm10
mulss  %xmm8,%xmm10
xorps  %xmm0,%xmm0
movaps %xmm4,%xmm1
addss  %xmm0,%xmm1
addss  %xmm14,%xmm1
addss  %xmm13,%xmm1
addss  %xmm3,%xmm1
ucomiss %xmm0,%xmm1
jne    12ee <target_x+0x1ce>
jnp    1574 <target_x+0x454>
mulss  %xmm4,%xmm4
movaps %xmm4,0xb0(%rsp)
movaps %xmm7,%xmm0
mulss  0xd3b(%rip),%xmm0
addss  0xd37(%rip),%xmm0
movaps %xmm9,%xmm1
mulss  0xd2f(%rip),%xmm1
addss  %xmm0,%xmm1
movss  %xmm2,0x8(%rsp)
movaps %xmm5,%xmm2
mulss  0xd1e(%rip),%xmm2
movaps %xmm11,0x70(%rsp)
mulss  %xmm11,%xmm2
addss  %xmm1,%xmm2
movss  0xd0b(%rip),%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm7,%xmm0
mulss  %xmm9,%xmm0
addss  %xmm2,%xmm0
mov    $0x2,%edi
movaps %xmm9,0x40(%rsp)
movss  %xmm5,0x10(%rsp)
movaps %xmm7,0x30(%rsp)
movss  %xmm8,0x18(%rsp)
movss  %xmm6,0x4(%rsp)
movss  %xmm10,0xc(%rsp)
movss  %xmm12,0x14(%rsp)
movaps %xmm3,0x60(%rsp)
movaps %xmm13,0x20(%rsp)
movaps %xmm14,0x50(%rsp)
call   1030 <pow@plt>
movss  %xmm0,0x1c(%rsp)
movaps 0x50(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movss  0xc87(%rip),%xmm0
mulss  0x10(%rsp),%xmm0
addss  0xc8d(%rip),%xmm0
movaps %xmm0,%xmm1
movss  0x4(%rsp),%xmm0
mulss  0xc80(%rip),%xmm0
addss  %xmm1,%xmm0
movss  0xc54(%rip),%xmm1
mulss  0x8(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0xc4d(%rip),%xmm0
mulss  0x30(%rsp),%xmm0
mulss  0x18(%rsp),%xmm0
addss  %xmm1,%xmm0
movaps %xmm0,%xmm1
movss  0xc(%rsp),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x50(%rsp),%xmm0
movss  0x1c(%rsp),%xmm1
mulss  0xb0(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x1c(%rsp)
movaps 0x20(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0x30(%rsp),%xmm2
movss  0xbf4(%rip),%xmm0
mulss  %xmm2,%xmm0
addss  0xbec(%rip),%xmm0
movaps 0x40(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  0xbe0(%rip),%xmm1
addss  %xmm0,%xmm1
movss  0xbd8(%rip),%xmm0
mulss  0x4(%rsp),%xmm0
mulss  %xmm2,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x20(%rsp),%xmm0
addss  0x1c(%rsp),%xmm0
movss  %xmm0,0x20(%rsp)
movaps 0x60(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps %xmm0,0x60(%rsp)
movss  0xb78(%rip),%xmm0
mulss  0x10(%rsp),%xmm0
addss  0xb8a(%rip),%xmm0
movss  0xb7a(%rip),%xmm1
mulss  0x4(%rsp),%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
movss  0x14(%rsp),%xmm1
mulss  0x8(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rsp),%xmm0
mulss  0x30(%rsp),%xmm0
addss  %xmm1,%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulss  0x60(%rsp),%xmm0
addss  0x20(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1537 <target_x+0x417>
sqrtss %xmm0,%xmm0
jmp    153c <target_x+0x41c>
call   1040 <sqrt@plt>
movaps 0x40(%rsp),%xmm9
movss  0x10(%rsp),%xmm5
movaps 0x30(%rsp),%xmm7
movss  0x18(%rsp),%xmm8
movss  0x4(%rsp),%xmm6
movss  0xc(%rsp),%xmm10
movaps 0x70(%rsp),%xmm11
movss  0x14(%rsp),%xmm12
movss  0x8(%rsp),%xmm2
mulss  %xmm7,%xmm10
mulss  0xaea(%rip),%xmm8
mulss  %xmm2,%xmm12
movss  0xad1(%rip),%xmm1
mulss  %xmm6,%xmm1
movss  0xabd(%rip),%xmm3
mulss  %xmm7,%xmm3
movss  0xaa1(%rip),%xmm2
mulss  %xmm5,%xmm2
movss  0xa8d(%rip),%xmm4
mulss  %xmm5,%xmm4
mulss  0xa85(%rip),%xmm5
addss  0xaa9(%rip),%xmm5
mulss  %xmm7,%xmm4
mulss  0xa81(%rip),%xmm7
addss  %xmm5,%xmm7
mulss  %xmm6,%xmm3
mulss  0xa79(%rip),%xmm6
addss  %xmm7,%xmm6
movss  0xa79(%rip),%xmm5
mulss  %xmm9,%xmm5
addss  %xmm6,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm9,%xmm2
addss  %xmm5,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm9,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm9,%xmm12
addss  %xmm1,%xmm12
mulss  %xmm11,%xmm8
addss  %xmm12,%xmm8
mulss  %xmm9,%xmm10
addss  %xmm8,%xmm10
movss  %xmm0,(%rbx)
movaps %xmm10,%xmm0
add    $0x120,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define float @target_x(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 = 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, 0xC03200C4A0000000
%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, 0xC032004180000000
%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 %55, %55
%77 = fmul float %64, %64
%78 = fmul float %55, 0xBF7029A300000000
%79 = fmul float %75, 0xBF76C7CCC0000000
%80 = extractelement <2 x float> %58, i64 0
%81 = fadd float %80, 0.000000e+00
%82 = extractelement <2 x float> %58, i64 1
%83 = fadd float %81, %82
%84 = extractelement <2 x float> %74, i64 0
%85 = fadd float %83, %84
%86 = extractelement <2 x float> %74, i64 1
%87 = fadd float %85, %86
%88 = fcmp oeq float %87, 0.000000e+00
br i1 %88, label %128, label %89
89: ; preds = %42
%90 = fmul <2 x float> %58, %58
%91 = extractelement <2 x float> %90, i64 0
%92 = tail call float @llvm.fmuladd.f32(float %55, float 0xBFA2CAF480000000, float 0xC042F6A4A0000000)
%93 = tail call float @llvm.fmuladd.f32(float %71, float 0x3FAC7E25A0000000, float %92)
%94 = fmul float %49, 0x3F88096EC0000000
%95 = tail call float @llvm.fmuladd.f32(float %94, float %76, float %93)
%96 = fmul float %49, 0xBF86C7CCC0000000
%97 = fmul float %96, %55
%98 = tail call float @llvm.fmuladd.f32(float %97, float %71, float %95)
%99 = tail call float @pow(float %98, i32 2)
%100 = fmul float %82, %82
%101 = tail call float @llvm.fmuladd.f32(float %49, float 0xBFA2CAF480000000, float 0x400E1700A0000000)
%102 = tail call float @llvm.fmuladd.f32(float %64, float 0x3FB0EA8380000000, float %101)
%103 = fmul float %77, 0xBF7029A300000000
%104 = tail call float @llvm.fmuladd.f32(float %103, float %71, float %102)
%105 = fmul float %55, 0x3F88096EC0000000
%106 = tail call float @llvm.fmuladd.f32(float %105, float %75, float %104)
%107 = tail call float @llvm.fmuladd.f32(float %79, float %71, float %106)
%108 = tail call float @pow(float %107, i32 2)
%109 = fmul float %100, %108
%110 = tail call float @llvm.fmuladd.f32(float %91, float %99, float %109)
%111 = fmul <2 x float> %74, %74
%112 = extractelement <2 x float> %111, i64 0
%113 = tail call float @llvm.fmuladd.f32(float %55, float 0x3FB0EA8380000000, float 0x404FB315E0000000)
%114 = tail call float @llvm.fmuladd.f32(float %71, float 0xBFB9E954C0000000, float %113)
%115 = fmul float %64, 0xBF8029A300000000
%116 = fmul float %55, %115
%117 = tail call float @llvm.fmuladd.f32(float %116, float %71, float %114)
%118 = tail call float @pow(float %117, i32 2)
%119 = tail call float @llvm.fmuladd.f32(float %112, float %118, float %110)
%120 = fmul float %86, %86
%121 = tail call float @llvm.fmuladd.f32(float %49, float 0x3FAC7E25A0000000, float 0xC018B60AA0000000)
%122 = tail call float @llvm.fmuladd.f32(float %64, float 0xBFB9E954C0000000, float %121)
%123 = tail call float @llvm.fmuladd.f32(float %78, float %77, float %122)
%124 = tail call float @llvm.fmuladd.f32(float %79, float %55, float %123)
%125 = tail call float @pow(float %124, i32 2)
%126 = tail call float @llvm.fmuladd.f32(float %120, float %125, float %119)
%127 = tail call float @sqrt(float %126)
br label %128
128: ; preds = %42, %89
%129 = phi float [ %127, %89 ], [ 0.000000e+00, %42 ]
%130 = fmul float %79, %55
%131 = fmul float %75, 0x3F78096EC0000000
%132 = fmul float %78, %77
%133 = fmul float %64, 0xBFB9E954C0000000
%134 = fmul float %55, 0x3FB0EA8380000000
%135 = fmul float %49, 0x3FAC7E25A0000000
%136 = fmul float %49, 0xBFA2CAF480000000
%137 = tail call float @llvm.fmuladd.f32(float %49, float 0xC042F6A4A0000000, float 0x3FF3C94540000000)
%138 = tail call float @llvm.fmuladd.f32(float %55, float 0x400E1700A0000000, float %137)
%139 = tail call float @llvm.fmuladd.f32(float %64, float 0x404FB315E0000000, float %138)
%140 = tail call float @llvm.fmuladd.f32(float %71, float 0xC018B60AA0000000, float %139)
%141 = tail call float @llvm.fmuladd.f32(float %136, float %55, float %140)
%142 = tail call float @llvm.fmuladd.f32(float %135, float %71, float %141)
%143 = tail call float @llvm.fmuladd.f32(float %134, float %64, float %142)
%144 = tail call float @llvm.fmuladd.f32(float %133, float %71, float %143)
%145 = tail call float @llvm.fmuladd.f32(float %132, float %71, float %144)
%146 = tail call float @llvm.fmuladd.f32(float %131, float %76, float %145)
%147 = tail call float @llvm.fmuladd.f32(float %130, float %71, float %146)
store float %129, float* %1
ret float %147
}