float myFunc(const int vIndex, const float *restrict P,
             const float *restrict ex, const int nExamples,
             float *restrict pred) {
  float in[2];
  in[0] = ex[IN(0, nExamples, vIndex)];
  in[1] = ex[IN(1, nExamples, vIndex)];
  register float h1_0 = P[0];
  register float h1_1 = P[1];
  register float h1_2 = P[2];
  register float h1_3 = P[3];
  register float h1_4 = P[4];
  register float h1_5 = P[5];
  register float h1_6 = P[6];
  register float h1_7 = P[7];
  register float h1_8 = P[8];
  register float h1_9 = P[9];
  h1_0 += in[0] * P[10];
  h1_1 += in[0] * P[11];
  h1_2 += in[0] * P[12];
  h1_3 += in[0] * P[13];
  h1_4 += in[0] * P[14];
  h1_5 += in[0] * P[15];
  h1_6 += in[0] * P[16];
  h1_7 += in[0] * P[17];
  h1_8 += in[0] * P[18];
  h1_9 += in[0] * P[19];
  h1_0 += in[1] * P[20];
  h1_1 += in[1] * P[21];
  h1_2 += in[1] * P[22];
  h1_3 += in[1] * P[23];
  h1_4 += in[1] * P[24];
  h1_5 += in[1] * P[25];
  h1_6 += in[1] * P[26];
  h1_7 += in[1] * P[27];
  h1_8 += in[1] * P[28];
  h1_9 += in[1] * P[29];
  h1_0 = G(h1_0);
  h1_1 = G(h1_1);
  h1_2 = G(h1_2);
  h1_3 = G(h1_3);
  h1_4 = G(h1_4);
  h1_5 = G(h1_5);
  h1_6 = G(h1_6);
  h1_7 = G(h1_7);
  h1_8 = G(h1_8);
  h1_9 = G(h1_9);
  register float h2_0 = P[30];
  h2_0 += h1_0 * P[31];
  h2_0 += h1_1 * P[32];
  h2_0 += h1_2 * P[33];
  h2_0 += h1_3 * P[34];
  h2_0 += h1_4 * P[35];
  h2_0 += h1_5 * P[36];
  h2_0 += h1_6 * P[37];
  h2_0 += h1_7 * P[38];
  h2_0 += h1_8 * P[39];
  h2_0 += h1_9 * P[40];
  register float h3_0 = P[41];
  register float h3_1 = P[42];
  register float h3_2 = P[43];
  register float h3_3 = P[44];
  register float h3_4 = P[45];
  register float h3_5 = P[46];
  register float h3_6 = P[47];
  register float h3_7 = P[48];
  register float h3_8 = P[49];
  register float h3_9 = P[50];
  h3_0 += h2_0 * P[51];
  h3_1 += h2_0 * P[52];
  h3_2 += h2_0 * P[53];
  h3_3 += h2_0 * P[54];
  h3_4 += h2_0 * P[55];
  h3_5 += h2_0 * P[56];
  h3_6 += h2_0 * P[57];
  h3_7 += h2_0 * P[58];
  h3_8 += h2_0 * P[59];
  h3_9 += h2_0 * P[60];
  h3_0 = G(h3_0);
  h3_1 = G(h3_1);
  h3_2 = G(h3_2);
  h3_3 = G(h3_3);
  h3_4 = G(h3_4);
  h3_5 = G(h3_5);
  h3_6 = G(h3_6);
  h3_7 = G(h3_7);
  h3_8 = G(h3_8);
  h3_9 = G(h3_9);
  register float o, sum = 0.f;
  o = P[61];
  o += h3_0 * P[62];
  o += h3_1 * P[63];
  o += h3_2 * P[64];
  o += h3_3 * P[65];
  o += h3_4 * P[66];
  o += h3_5 * P[67];
  o += h3_6 * P[68];
  o += h3_7 * P[69];
  o += h3_8 * P[70];
  o += h3_9 * P[71];
  o -= in[0];
  sum += o * o;
  o = P[72];
  o += h3_0 * P[73];
  o += h3_1 * P[74];
  o += h3_2 * P[75];
  o += h3_3 * P[76];
  o += h3_4 * P[77];
  o += h3_5 * P[78];
  o += h3_6 * P[79];
  o += h3_7 * P[80];
  o += h3_8 * P[81];
  o += h3_9 * P[82];
  o -= in[1];
  sum += o * o;
  return (sum);
}


x86 assembly (clang, -O0):
<myFunc>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x1c(%rbp),%esi
mov    -0x4(%rbp),%edx
xor    %edi,%edi
mov    $0x0,%al
call   1040 <IN@plt>
mov    %eax,%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x1c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <IN@plt>
mov    %eax,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x34(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x80(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x84(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x88(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8c(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x90(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x94(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x98(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x9c(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xa0(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xa4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xa8(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xac(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0xb0(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xb4(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0xb8(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0xbc(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc0(%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc4(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc8(%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xcc(%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xd0(%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xd4(%rax),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xd8(%rax),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xdc(%rax),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xe0(%rax),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xe4(%rax),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xe8(%rax),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xec(%rax),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xf0(%rax),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0xf4(%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xf8(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0xfc(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x100(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x104(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x108(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10c(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x110(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x114(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x118(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  0x11c(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x30(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x120(%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x124(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x128(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x12c(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x130(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x134(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x138(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x13c(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x140(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x144(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  0x148(%rax),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x2c(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<myFunc>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x38,%rsp
mov    %ecx,%r15d
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %edi,%ebp
xor    %edi,%edi
mov    %ecx,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <IN@plt>
cltq
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,0x30(%rsp)
mov    $0x1,%edi
mov    %r15d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <IN@plt>
cltq
movss  0x28(%rbx),%xmm10
movss  0x30(%rsp),%xmm0
mulss  %xmm0,%xmm10
addss  (%rbx),%xmm10
movss  0x2c(%rbx),%xmm11
mulss  %xmm0,%xmm11
addss  0x4(%rbx),%xmm11
movss  0x30(%rbx),%xmm12
mulss  %xmm0,%xmm12
addss  0x8(%rbx),%xmm12
movss  0x34(%rbx),%xmm3
mulss  %xmm0,%xmm3
addss  0xc(%rbx),%xmm3
movss  0x38(%rbx),%xmm4
mulss  %xmm0,%xmm4
addss  0x10(%rbx),%xmm4
movss  0x3c(%rbx),%xmm5
mulss  %xmm0,%xmm5
addss  0x14(%rbx),%xmm5
movss  0x40(%rbx),%xmm6
mulss  %xmm0,%xmm6
addss  0x18(%rbx),%xmm6
movss  0x44(%rbx),%xmm7
mulss  %xmm0,%xmm7
addss  0x1c(%rbx),%xmm7
movss  0x48(%rbx),%xmm8
mulss  %xmm0,%xmm8
addss  0x20(%rbx),%xmm8
movss  0x4c(%rbx),%xmm9
mulss  %xmm0,%xmm9
addss  0x24(%rbx),%xmm9
movss  (%r14,%rax,4),%xmm1
movss  %xmm1,0x34(%rsp)
movss  0x50(%rbx),%xmm0
mulss  %xmm1,%xmm0
addss  %xmm10,%xmm0
movss  0x54(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm11,%xmm2
movss  %xmm2,0x20(%rsp)
movss  0x58(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm12,%xmm2
movss  %xmm2,0x18(%rsp)
movss  0x5c(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x10(%rsp)
movss  0x60(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x8(%rsp)
movss  0x64(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm5,%xmm2
movss  %xmm2,0xc(%rsp)
movss  0x68(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm6,%xmm2
movss  %xmm2,0x14(%rsp)
movss  0x6c(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,0x1c(%rsp)
movss  0x70(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm8,%xmm2
movss  %xmm2,0x24(%rsp)
movss  0x74(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm9,%xmm2
movss  %xmm2,0x28(%rsp)
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x2c(%rsp)
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x18(%rsp)
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0xc(%rsp)
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x14(%rsp)
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x24(%rsp)
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
cvtsi2ss %eax,%xmm1
movss  0x2c(%rsp),%xmm0
mulss  0x7c(%rbx),%xmm0
addss  0x78(%rbx),%xmm0
movss  0x20(%rsp),%xmm2
mulss  0x80(%rbx),%xmm2
addss  %xmm0,%xmm2
movss  0x18(%rsp),%xmm0
mulss  0x84(%rbx),%xmm0
addss  %xmm2,%xmm0
movss  0x10(%rsp),%xmm2
mulss  0x88(%rbx),%xmm2
addss  %xmm0,%xmm2
movss  0x8(%rsp),%xmm0
mulss  0x8c(%rbx),%xmm0
movss  0xc(%rsp),%xmm3
mulss  0x90(%rbx),%xmm3
addss  %xmm2,%xmm0
addss  %xmm0,%xmm3
movss  0x14(%rsp),%xmm0
mulss  0x94(%rbx),%xmm0
addss  %xmm3,%xmm0
movss  0x1c(%rsp),%xmm2
mulss  0x98(%rbx),%xmm2
addss  %xmm0,%xmm2
movss  0x24(%rsp),%xmm0
mulss  0x9c(%rbx),%xmm0
mulss  0xa0(%rbx),%xmm1
addss  %xmm2,%xmm0
addss  %xmm0,%xmm1
movss  0xcc(%rbx),%xmm0
mulss  %xmm1,%xmm0
addss  0xa4(%rbx),%xmm0
movss  0xd0(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xa8(%rbx),%xmm2
movss  %xmm2,0x24(%rsp)
movss  0xd4(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xac(%rbx),%xmm2
movss  %xmm2,0x20(%rsp)
movss  0xd8(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xb0(%rbx),%xmm2
movss  %xmm2,0x18(%rsp)
movss  0xdc(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xb4(%rbx),%xmm2
movss  %xmm2,0x10(%rsp)
movss  0xe0(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xb8(%rbx),%xmm2
movss  %xmm2,0x8(%rsp)
movss  0xe4(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xbc(%rbx),%xmm2
movss  %xmm2,0xc(%rsp)
movss  0xe8(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xc0(%rbx),%xmm2
movss  %xmm2,0x14(%rsp)
movss  0xec(%rbx),%xmm2
mulss  %xmm1,%xmm2
addss  0xc4(%rbx),%xmm2
movss  %xmm2,0x1c(%rsp)
mulss  0xf0(%rbx),%xmm1
addss  0xc8(%rbx),%xmm1
movss  %xmm1,0x28(%rsp)
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x2c(%rsp)
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x24(%rsp)
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x18(%rsp)
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0xc(%rsp)
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x14(%rsp)
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <G@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0xf8(%rbx),%xmm1
movss  0x2c(%rsp),%xmm8
mulss  %xmm8,%xmm1
addss  0xf4(%rbx),%xmm1
movss  0xfc(%rbx),%xmm2
movss  0x24(%rsp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  0x100(%rbx),%xmm1
movss  0x20(%rsp),%xmm9
mulss  %xmm9,%xmm1
addss  %xmm2,%xmm1
movss  0x104(%rbx),%xmm2
movss  0x18(%rsp),%xmm10
mulss  %xmm10,%xmm2
addss  %xmm1,%xmm2
movss  0x108(%rbx),%xmm1
movss  0x10(%rsp),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm2,%xmm1
movss  0x10c(%rbx),%xmm2
movss  0x8(%rsp),%xmm11
mulss  %xmm11,%xmm2
addss  %xmm1,%xmm2
movss  0x110(%rbx),%xmm1
movss  0xc(%rsp),%xmm6
mulss  %xmm6,%xmm1
addss  %xmm2,%xmm1
movss  0x114(%rbx),%xmm2
movss  0x14(%rsp),%xmm7
mulss  %xmm7,%xmm2
addss  %xmm1,%xmm2
movss  0x118(%rbx),%xmm1
movss  0x1c(%rsp),%xmm5
mulss  %xmm5,%xmm1
addss  %xmm2,%xmm1
movss  0x11c(%rbx),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
subss  0x30(%rsp),%xmm2
mulss  %xmm2,%xmm2
xorps  %xmm1,%xmm1
addss  %xmm2,%xmm1
movaps %xmm8,%xmm2
mulss  0x124(%rbx),%xmm2
addss  0x120(%rbx),%xmm2
mulss  0x128(%rbx),%xmm3
addss  %xmm2,%xmm3
movaps %xmm9,%xmm2
mulss  0x12c(%rbx),%xmm2
addss  %xmm3,%xmm2
movaps %xmm10,%xmm3
mulss  0x130(%rbx),%xmm3
mulss  0x134(%rbx),%xmm4
addss  %xmm2,%xmm3
addss  %xmm3,%xmm4
movaps %xmm11,%xmm2
mulss  0x138(%rbx),%xmm2
addss  %xmm4,%xmm2
movaps %xmm6,%xmm3
mulss  0x13c(%rbx),%xmm3
addss  %xmm2,%xmm3
movaps %xmm7,%xmm2
mulss  0x140(%rbx),%xmm2
movaps %xmm5,%xmm4
mulss  0x144(%rbx),%xmm4
addss  %xmm3,%xmm2
addss  %xmm2,%xmm4
mulss  0x148(%rbx),%xmm0
addss  %xmm4,%xmm0
subss  0x34(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x38,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define float @myFunc(i32 %0, float* noalias %1, float* noalias %2, i32 %3, float* noalias %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca [2 x float]
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%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
store i32 %0, i32* %6
store float* %1, float** %7
store float* %2, float** %8
store i32 %3, i32* %9
store float* %4, float** %10
%35 = load float*, float** %8
%36 = load i32, i32* %9
%37 = load i32, i32* %6
%38 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @IN to i32 (i32, i32, i32, ...)*)(i32 0, i32 %36, i32 %37)
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %35, i64 %39
%41 = load float, float* %40
%42 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
store float %41, float* %42
%43 = load float*, float** %8
%44 = load i32, i32* %9
%45 = load i32, i32* %6
%46 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @IN to i32 (i32, i32, i32, ...)*)(i32 1, i32 %44, i32 %45)
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %43, i64 %47
%49 = load float, float* %48
%50 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
store float %49, float* %50
%51 = load float*, float** %7
%52 = getelementptr inbounds float, float* %51, i64 0
%53 = load float, float* %52
store float %53, float* %12
%54 = load float*, float** %7
%55 = getelementptr inbounds float, float* %54, i64 1
%56 = load float, float* %55
store float %56, float* %13
%57 = load float*, float** %7
%58 = getelementptr inbounds float, float* %57, i64 2
%59 = load float, float* %58
store float %59, float* %14
%60 = load float*, float** %7
%61 = getelementptr inbounds float, float* %60, i64 3
%62 = load float, float* %61
store float %62, float* %15
%63 = load float*, float** %7
%64 = getelementptr inbounds float, float* %63, i64 4
%65 = load float, float* %64
store float %65, float* %16
%66 = load float*, float** %7
%67 = getelementptr inbounds float, float* %66, i64 5
%68 = load float, float* %67
store float %68, float* %17
%69 = load float*, float** %7
%70 = getelementptr inbounds float, float* %69, i64 6
%71 = load float, float* %70
store float %71, float* %18
%72 = load float*, float** %7
%73 = getelementptr inbounds float, float* %72, i64 7
%74 = load float, float* %73
store float %74, float* %19
%75 = load float*, float** %7
%76 = getelementptr inbounds float, float* %75, i64 8
%77 = load float, float* %76
store float %77, float* %20
%78 = load float*, float** %7
%79 = getelementptr inbounds float, float* %78, i64 9
%80 = load float, float* %79
store float %80, float* %21
%81 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%82 = load float, float* %81
%83 = load float*, float** %7
%84 = getelementptr inbounds float, float* %83, i64 10
%85 = load float, float* %84
%86 = load float, float* %12
%87 = call float @llvm.fmuladd.f32(float %82, float %85, float %86)
store float %87, float* %12
%88 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%89 = load float, float* %88
%90 = load float*, float** %7
%91 = getelementptr inbounds float, float* %90, i64 11
%92 = load float, float* %91
%93 = load float, float* %13
%94 = call float @llvm.fmuladd.f32(float %89, float %92, float %93)
store float %94, float* %13
%95 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%96 = load float, float* %95
%97 = load float*, float** %7
%98 = getelementptr inbounds float, float* %97, i64 12
%99 = load float, float* %98
%100 = load float, float* %14
%101 = call float @llvm.fmuladd.f32(float %96, float %99, float %100)
store float %101, float* %14
%102 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%103 = load float, float* %102
%104 = load float*, float** %7
%105 = getelementptr inbounds float, float* %104, i64 13
%106 = load float, float* %105
%107 = load float, float* %15
%108 = call float @llvm.fmuladd.f32(float %103, float %106, float %107)
store float %108, float* %15
%109 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%110 = load float, float* %109
%111 = load float*, float** %7
%112 = getelementptr inbounds float, float* %111, i64 14
%113 = load float, float* %112
%114 = load float, float* %16
%115 = call float @llvm.fmuladd.f32(float %110, float %113, float %114)
store float %115, float* %16
%116 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%117 = load float, float* %116
%118 = load float*, float** %7
%119 = getelementptr inbounds float, float* %118, i64 15
%120 = load float, float* %119
%121 = load float, float* %17
%122 = call float @llvm.fmuladd.f32(float %117, float %120, float %121)
store float %122, float* %17
%123 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%124 = load float, float* %123
%125 = load float*, float** %7
%126 = getelementptr inbounds float, float* %125, i64 16
%127 = load float, float* %126
%128 = load float, float* %18
%129 = call float @llvm.fmuladd.f32(float %124, float %127, float %128)
store float %129, float* %18
%130 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%131 = load float, float* %130
%132 = load float*, float** %7
%133 = getelementptr inbounds float, float* %132, i64 17
%134 = load float, float* %133
%135 = load float, float* %19
%136 = call float @llvm.fmuladd.f32(float %131, float %134, float %135)
store float %136, float* %19
%137 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%138 = load float, float* %137
%139 = load float*, float** %7
%140 = getelementptr inbounds float, float* %139, i64 18
%141 = load float, float* %140
%142 = load float, float* %20
%143 = call float @llvm.fmuladd.f32(float %138, float %141, float %142)
store float %143, float* %20
%144 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%145 = load float, float* %144
%146 = load float*, float** %7
%147 = getelementptr inbounds float, float* %146, i64 19
%148 = load float, float* %147
%149 = load float, float* %21
%150 = call float @llvm.fmuladd.f32(float %145, float %148, float %149)
store float %150, float* %21
%151 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%152 = load float, float* %151
%153 = load float*, float** %7
%154 = getelementptr inbounds float, float* %153, i64 20
%155 = load float, float* %154
%156 = load float, float* %12
%157 = call float @llvm.fmuladd.f32(float %152, float %155, float %156)
store float %157, float* %12
%158 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%159 = load float, float* %158
%160 = load float*, float** %7
%161 = getelementptr inbounds float, float* %160, i64 21
%162 = load float, float* %161
%163 = load float, float* %13
%164 = call float @llvm.fmuladd.f32(float %159, float %162, float %163)
store float %164, float* %13
%165 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%166 = load float, float* %165
%167 = load float*, float** %7
%168 = getelementptr inbounds float, float* %167, i64 22
%169 = load float, float* %168
%170 = load float, float* %14
%171 = call float @llvm.fmuladd.f32(float %166, float %169, float %170)
store float %171, float* %14
%172 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%173 = load float, float* %172
%174 = load float*, float** %7
%175 = getelementptr inbounds float, float* %174, i64 23
%176 = load float, float* %175
%177 = load float, float* %15
%178 = call float @llvm.fmuladd.f32(float %173, float %176, float %177)
store float %178, float* %15
%179 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%180 = load float, float* %179
%181 = load float*, float** %7
%182 = getelementptr inbounds float, float* %181, i64 24
%183 = load float, float* %182
%184 = load float, float* %16
%185 = call float @llvm.fmuladd.f32(float %180, float %183, float %184)
store float %185, float* %16
%186 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%187 = load float, float* %186
%188 = load float*, float** %7
%189 = getelementptr inbounds float, float* %188, i64 25
%190 = load float, float* %189
%191 = load float, float* %17
%192 = call float @llvm.fmuladd.f32(float %187, float %190, float %191)
store float %192, float* %17
%193 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%194 = load float, float* %193
%195 = load float*, float** %7
%196 = getelementptr inbounds float, float* %195, i64 26
%197 = load float, float* %196
%198 = load float, float* %18
%199 = call float @llvm.fmuladd.f32(float %194, float %197, float %198)
store float %199, float* %18
%200 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%201 = load float, float* %200
%202 = load float*, float** %7
%203 = getelementptr inbounds float, float* %202, i64 27
%204 = load float, float* %203
%205 = load float, float* %19
%206 = call float @llvm.fmuladd.f32(float %201, float %204, float %205)
store float %206, float* %19
%207 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%208 = load float, float* %207
%209 = load float*, float** %7
%210 = getelementptr inbounds float, float* %209, i64 28
%211 = load float, float* %210
%212 = load float, float* %20
%213 = call float @llvm.fmuladd.f32(float %208, float %211, float %212)
store float %213, float* %20
%214 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%215 = load float, float* %214
%216 = load float*, float** %7
%217 = getelementptr inbounds float, float* %216, i64 29
%218 = load float, float* %217
%219 = load float, float* %21
%220 = call float @llvm.fmuladd.f32(float %215, float %218, float %219)
store float %220, float* %21
%221 = load float, float* %12
%222 = fpext float %221 to double
%223 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %222)
%224 = sitofp i32 %223 to float
store float %224, float* %12
%225 = load float, float* %13
%226 = fpext float %225 to double
%227 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %226)
%228 = sitofp i32 %227 to float
store float %228, float* %13
%229 = load float, float* %14
%230 = fpext float %229 to double
%231 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %230)
%232 = sitofp i32 %231 to float
store float %232, float* %14
%233 = load float, float* %15
%234 = fpext float %233 to double
%235 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %234)
%236 = sitofp i32 %235 to float
store float %236, float* %15
%237 = load float, float* %16
%238 = fpext float %237 to double
%239 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %238)
%240 = sitofp i32 %239 to float
store float %240, float* %16
%241 = load float, float* %17
%242 = fpext float %241 to double
%243 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %242)
%244 = sitofp i32 %243 to float
store float %244, float* %17
%245 = load float, float* %18
%246 = fpext float %245 to double
%247 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %246)
%248 = sitofp i32 %247 to float
store float %248, float* %18
%249 = load float, float* %19
%250 = fpext float %249 to double
%251 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %250)
%252 = sitofp i32 %251 to float
store float %252, float* %19
%253 = load float, float* %20
%254 = fpext float %253 to double
%255 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %254)
%256 = sitofp i32 %255 to float
store float %256, float* %20
%257 = load float, float* %21
%258 = fpext float %257 to double
%259 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %258)
%260 = sitofp i32 %259 to float
store float %260, float* %21
%261 = load float*, float** %7
%262 = getelementptr inbounds float, float* %261, i64 30
%263 = load float, float* %262
store float %263, float* %22
%264 = load float, float* %12
%265 = load float*, float** %7
%266 = getelementptr inbounds float, float* %265, i64 31
%267 = load float, float* %266
%268 = load float, float* %22
%269 = call float @llvm.fmuladd.f32(float %264, float %267, float %268)
store float %269, float* %22
%270 = load float, float* %13
%271 = load float*, float** %7
%272 = getelementptr inbounds float, float* %271, i64 32
%273 = load float, float* %272
%274 = load float, float* %22
%275 = call float @llvm.fmuladd.f32(float %270, float %273, float %274)
store float %275, float* %22
%276 = load float, float* %14
%277 = load float*, float** %7
%278 = getelementptr inbounds float, float* %277, i64 33
%279 = load float, float* %278
%280 = load float, float* %22
%281 = call float @llvm.fmuladd.f32(float %276, float %279, float %280)
store float %281, float* %22
%282 = load float, float* %15
%283 = load float*, float** %7
%284 = getelementptr inbounds float, float* %283, i64 34
%285 = load float, float* %284
%286 = load float, float* %22
%287 = call float @llvm.fmuladd.f32(float %282, float %285, float %286)
store float %287, float* %22
%288 = load float, float* %16
%289 = load float*, float** %7
%290 = getelementptr inbounds float, float* %289, i64 35
%291 = load float, float* %290
%292 = load float, float* %22
%293 = call float @llvm.fmuladd.f32(float %288, float %291, float %292)
store float %293, float* %22
%294 = load float, float* %17
%295 = load float*, float** %7
%296 = getelementptr inbounds float, float* %295, i64 36
%297 = load float, float* %296
%298 = load float, float* %22
%299 = call float @llvm.fmuladd.f32(float %294, float %297, float %298)
store float %299, float* %22
%300 = load float, float* %18
%301 = load float*, float** %7
%302 = getelementptr inbounds float, float* %301, i64 37
%303 = load float, float* %302
%304 = load float, float* %22
%305 = call float @llvm.fmuladd.f32(float %300, float %303, float %304)
store float %305, float* %22
%306 = load float, float* %19
%307 = load float*, float** %7
%308 = getelementptr inbounds float, float* %307, i64 38
%309 = load float, float* %308
%310 = load float, float* %22
%311 = call float @llvm.fmuladd.f32(float %306, float %309, float %310)
store float %311, float* %22
%312 = load float, float* %20
%313 = load float*, float** %7
%314 = getelementptr inbounds float, float* %313, i64 39
%315 = load float, float* %314
%316 = load float, float* %22
%317 = call float @llvm.fmuladd.f32(float %312, float %315, float %316)
store float %317, float* %22
%318 = load float, float* %21
%319 = load float*, float** %7
%320 = getelementptr inbounds float, float* %319, i64 40
%321 = load float, float* %320
%322 = load float, float* %22
%323 = call float @llvm.fmuladd.f32(float %318, float %321, float %322)
store float %323, float* %22
%324 = load float*, float** %7
%325 = getelementptr inbounds float, float* %324, i64 41
%326 = load float, float* %325
store float %326, float* %23
%327 = load float*, float** %7
%328 = getelementptr inbounds float, float* %327, i64 42
%329 = load float, float* %328
store float %329, float* %24
%330 = load float*, float** %7
%331 = getelementptr inbounds float, float* %330, i64 43
%332 = load float, float* %331
store float %332, float* %25
%333 = load float*, float** %7
%334 = getelementptr inbounds float, float* %333, i64 44
%335 = load float, float* %334
store float %335, float* %26
%336 = load float*, float** %7
%337 = getelementptr inbounds float, float* %336, i64 45
%338 = load float, float* %337
store float %338, float* %27
%339 = load float*, float** %7
%340 = getelementptr inbounds float, float* %339, i64 46
%341 = load float, float* %340
store float %341, float* %28
%342 = load float*, float** %7
%343 = getelementptr inbounds float, float* %342, i64 47
%344 = load float, float* %343
store float %344, float* %29
%345 = load float*, float** %7
%346 = getelementptr inbounds float, float* %345, i64 48
%347 = load float, float* %346
store float %347, float* %30
%348 = load float*, float** %7
%349 = getelementptr inbounds float, float* %348, i64 49
%350 = load float, float* %349
store float %350, float* %31
%351 = load float*, float** %7
%352 = getelementptr inbounds float, float* %351, i64 50
%353 = load float, float* %352
store float %353, float* %32
%354 = load float, float* %22
%355 = load float*, float** %7
%356 = getelementptr inbounds float, float* %355, i64 51
%357 = load float, float* %356
%358 = load float, float* %23
%359 = call float @llvm.fmuladd.f32(float %354, float %357, float %358)
store float %359, float* %23
%360 = load float, float* %22
%361 = load float*, float** %7
%362 = getelementptr inbounds float, float* %361, i64 52
%363 = load float, float* %362
%364 = load float, float* %24
%365 = call float @llvm.fmuladd.f32(float %360, float %363, float %364)
store float %365, float* %24
%366 = load float, float* %22
%367 = load float*, float** %7
%368 = getelementptr inbounds float, float* %367, i64 53
%369 = load float, float* %368
%370 = load float, float* %25
%371 = call float @llvm.fmuladd.f32(float %366, float %369, float %370)
store float %371, float* %25
%372 = load float, float* %22
%373 = load float*, float** %7
%374 = getelementptr inbounds float, float* %373, i64 54
%375 = load float, float* %374
%376 = load float, float* %26
%377 = call float @llvm.fmuladd.f32(float %372, float %375, float %376)
store float %377, float* %26
%378 = load float, float* %22
%379 = load float*, float** %7
%380 = getelementptr inbounds float, float* %379, i64 55
%381 = load float, float* %380
%382 = load float, float* %27
%383 = call float @llvm.fmuladd.f32(float %378, float %381, float %382)
store float %383, float* %27
%384 = load float, float* %22
%385 = load float*, float** %7
%386 = getelementptr inbounds float, float* %385, i64 56
%387 = load float, float* %386
%388 = load float, float* %28
%389 = call float @llvm.fmuladd.f32(float %384, float %387, float %388)
store float %389, float* %28
%390 = load float, float* %22
%391 = load float*, float** %7
%392 = getelementptr inbounds float, float* %391, i64 57
%393 = load float, float* %392
%394 = load float, float* %29
%395 = call float @llvm.fmuladd.f32(float %390, float %393, float %394)
store float %395, float* %29
%396 = load float, float* %22
%397 = load float*, float** %7
%398 = getelementptr inbounds float, float* %397, i64 58
%399 = load float, float* %398
%400 = load float, float* %30
%401 = call float @llvm.fmuladd.f32(float %396, float %399, float %400)
store float %401, float* %30
%402 = load float, float* %22
%403 = load float*, float** %7
%404 = getelementptr inbounds float, float* %403, i64 59
%405 = load float, float* %404
%406 = load float, float* %31
%407 = call float @llvm.fmuladd.f32(float %402, float %405, float %406)
store float %407, float* %31
%408 = load float, float* %22
%409 = load float*, float** %7
%410 = getelementptr inbounds float, float* %409, i64 60
%411 = load float, float* %410
%412 = load float, float* %32
%413 = call float @llvm.fmuladd.f32(float %408, float %411, float %412)
store float %413, float* %32
%414 = load float, float* %23
%415 = fpext float %414 to double
%416 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %415)
%417 = sitofp i32 %416 to float
store float %417, float* %23
%418 = load float, float* %24
%419 = fpext float %418 to double
%420 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %419)
%421 = sitofp i32 %420 to float
store float %421, float* %24
%422 = load float, float* %25
%423 = fpext float %422 to double
%424 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %423)
%425 = sitofp i32 %424 to float
store float %425, float* %25
%426 = load float, float* %26
%427 = fpext float %426 to double
%428 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %427)
%429 = sitofp i32 %428 to float
store float %429, float* %26
%430 = load float, float* %27
%431 = fpext float %430 to double
%432 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %431)
%433 = sitofp i32 %432 to float
store float %433, float* %27
%434 = load float, float* %28
%435 = fpext float %434 to double
%436 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %435)
%437 = sitofp i32 %436 to float
store float %437, float* %28
%438 = load float, float* %29
%439 = fpext float %438 to double
%440 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %439)
%441 = sitofp i32 %440 to float
store float %441, float* %29
%442 = load float, float* %30
%443 = fpext float %442 to double
%444 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %443)
%445 = sitofp i32 %444 to float
store float %445, float* %30
%446 = load float, float* %31
%447 = fpext float %446 to double
%448 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %447)
%449 = sitofp i32 %448 to float
store float %449, float* %31
%450 = load float, float* %32
%451 = fpext float %450 to double
%452 = call i32 (double, ...) bitcast (i32 (...)* @G to i32 (double, ...)*)(double %451)
%453 = sitofp i32 %452 to float
store float %453, float* %32
store float 0.000000e+00, float* %34
%454 = load float*, float** %7
%455 = getelementptr inbounds float, float* %454, i64 61
%456 = load float, float* %455
store float %456, float* %33
%457 = load float, float* %23
%458 = load float*, float** %7
%459 = getelementptr inbounds float, float* %458, i64 62
%460 = load float, float* %459
%461 = load float, float* %33
%462 = call float @llvm.fmuladd.f32(float %457, float %460, float %461)
store float %462, float* %33
%463 = load float, float* %24
%464 = load float*, float** %7
%465 = getelementptr inbounds float, float* %464, i64 63
%466 = load float, float* %465
%467 = load float, float* %33
%468 = call float @llvm.fmuladd.f32(float %463, float %466, float %467)
store float %468, float* %33
%469 = load float, float* %25
%470 = load float*, float** %7
%471 = getelementptr inbounds float, float* %470, i64 64
%472 = load float, float* %471
%473 = load float, float* %33
%474 = call float @llvm.fmuladd.f32(float %469, float %472, float %473)
store float %474, float* %33
%475 = load float, float* %26
%476 = load float*, float** %7
%477 = getelementptr inbounds float, float* %476, i64 65
%478 = load float, float* %477
%479 = load float, float* %33
%480 = call float @llvm.fmuladd.f32(float %475, float %478, float %479)
store float %480, float* %33
%481 = load float, float* %27
%482 = load float*, float** %7
%483 = getelementptr inbounds float, float* %482, i64 66
%484 = load float, float* %483
%485 = load float, float* %33
%486 = call float @llvm.fmuladd.f32(float %481, float %484, float %485)
store float %486, float* %33
%487 = load float, float* %28
%488 = load float*, float** %7
%489 = getelementptr inbounds float, float* %488, i64 67
%490 = load float, float* %489
%491 = load float, float* %33
%492 = call float @llvm.fmuladd.f32(float %487, float %490, float %491)
store float %492, float* %33
%493 = load float, float* %29
%494 = load float*, float** %7
%495 = getelementptr inbounds float, float* %494, i64 68
%496 = load float, float* %495
%497 = load float, float* %33
%498 = call float @llvm.fmuladd.f32(float %493, float %496, float %497)
store float %498, float* %33
%499 = load float, float* %30
%500 = load float*, float** %7
%501 = getelementptr inbounds float, float* %500, i64 69
%502 = load float, float* %501
%503 = load float, float* %33
%504 = call float @llvm.fmuladd.f32(float %499, float %502, float %503)
store float %504, float* %33
%505 = load float, float* %31
%506 = load float*, float** %7
%507 = getelementptr inbounds float, float* %506, i64 70
%508 = load float, float* %507
%509 = load float, float* %33
%510 = call float @llvm.fmuladd.f32(float %505, float %508, float %509)
store float %510, float* %33
%511 = load float, float* %32
%512 = load float*, float** %7
%513 = getelementptr inbounds float, float* %512, i64 71
%514 = load float, float* %513
%515 = load float, float* %33
%516 = call float @llvm.fmuladd.f32(float %511, float %514, float %515)
store float %516, float* %33
%517 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 0
%518 = load float, float* %517
%519 = load float, float* %33
%520 = fsub float %519, %518
store float %520, float* %33
%521 = load float, float* %33
%522 = load float, float* %33
%523 = load float, float* %34
%524 = call float @llvm.fmuladd.f32(float %521, float %522, float %523)
store float %524, float* %34
%525 = load float*, float** %7
%526 = getelementptr inbounds float, float* %525, i64 72
%527 = load float, float* %526
store float %527, float* %33
%528 = load float, float* %23
%529 = load float*, float** %7
%530 = getelementptr inbounds float, float* %529, i64 73
%531 = load float, float* %530
%532 = load float, float* %33
%533 = call float @llvm.fmuladd.f32(float %528, float %531, float %532)
store float %533, float* %33
%534 = load float, float* %24
%535 = load float*, float** %7
%536 = getelementptr inbounds float, float* %535, i64 74
%537 = load float, float* %536
%538 = load float, float* %33
%539 = call float @llvm.fmuladd.f32(float %534, float %537, float %538)
store float %539, float* %33
%540 = load float, float* %25
%541 = load float*, float** %7
%542 = getelementptr inbounds float, float* %541, i64 75
%543 = load float, float* %542
%544 = load float, float* %33
%545 = call float @llvm.fmuladd.f32(float %540, float %543, float %544)
store float %545, float* %33
%546 = load float, float* %26
%547 = load float*, float** %7
%548 = getelementptr inbounds float, float* %547, i64 76
%549 = load float, float* %548
%550 = load float, float* %33
%551 = call float @llvm.fmuladd.f32(float %546, float %549, float %550)
store float %551, float* %33
%552 = load float, float* %27
%553 = load float*, float** %7
%554 = getelementptr inbounds float, float* %553, i64 77
%555 = load float, float* %554
%556 = load float, float* %33
%557 = call float @llvm.fmuladd.f32(float %552, float %555, float %556)
store float %557, float* %33
%558 = load float, float* %28
%559 = load float*, float** %7
%560 = getelementptr inbounds float, float* %559, i64 78
%561 = load float, float* %560
%562 = load float, float* %33
%563 = call float @llvm.fmuladd.f32(float %558, float %561, float %562)
store float %563, float* %33
%564 = load float, float* %29
%565 = load float*, float** %7
%566 = getelementptr inbounds float, float* %565, i64 79
%567 = load float, float* %566
%568 = load float, float* %33
%569 = call float @llvm.fmuladd.f32(float %564, float %567, float %568)
store float %569, float* %33
%570 = load float, float* %30
%571 = load float*, float** %7
%572 = getelementptr inbounds float, float* %571, i64 80
%573 = load float, float* %572
%574 = load float, float* %33
%575 = call float @llvm.fmuladd.f32(float %570, float %573, float %574)
store float %575, float* %33
%576 = load float, float* %31
%577 = load float*, float** %7
%578 = getelementptr inbounds float, float* %577, i64 81
%579 = load float, float* %578
%580 = load float, float* %33
%581 = call float @llvm.fmuladd.f32(float %576, float %579, float %580)
store float %581, float* %33
%582 = load float, float* %32
%583 = load float*, float** %7
%584 = getelementptr inbounds float, float* %583, i64 82
%585 = load float, float* %584
%586 = load float, float* %33
%587 = call float @llvm.fmuladd.f32(float %582, float %585, float %586)
store float %587, float* %33
%588 = getelementptr inbounds [2 x float], [2 x float]* %11, i64 0, i64 1
%589 = load float, float* %588
%590 = load float, float* %33
%591 = fsub float %590, %589
store float %591, float* %33
%592 = load float, float* %33
%593 = load float, float* %33
%594 = load float, float* %34
%595 = call float @llvm.fmuladd.f32(float %592, float %593, float %594)
store float %595, float* %34
%596 = load float, float* %34
ret float %596
}

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