int linearize(double T, double reacparam[][10], double f[], double r[],
              int loop, int inc, int ip, double dt, double Y0[], double Y[],
              double dY_dt[], double H, double rhob) {
  double nn1[12] = {1., 1., 1., 1., 1., 2., 3., 2., 1., 1., 2., 1.};
  double nn2[12] = {0., 1., 1., 0., 1., 0., 0., 1., 1., 1., 0., 1.};
  double nn3[12] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
  double nn4[12] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.};
  double nn5[12] = {0., 0., 1., 0., 0., 1., 0., 0., 1., 0., 2., 1.};
  double nn6[12] = {1., 1., 1., 2., 2., 1., 1., 1., 2., 3., 1., 1.};
  int i, j, g, h, k, l, n, i1, j1, ind;
  double cn1, cn2, cn3, cn4, cn5, cn6, rn1, rn2, rn3, rn4, rn5, rn6, yY[26 + 1];
  cn1 = cn2 = cn3 = cn4 = cn5 = cn6 = 0.;
  int fail;
  double bdln;
  int c0 = 0;
  int type[100 + 1], n1[100 + 1], n2[100 + 1], n3[100 + 1], n4[100 + 1],
      n5[100 + 1], n6[100 + 1];
  double rev[100 + 1], q9[100 + 1];
  double a[26 + 1][26 + 1], b[26 + 1], yx[26 + 1];
  int icnvm;
  double x[26 + 1], a0[26 + 1][26 + 1], cx, sum, xdy, t;
  int nord, test;
  for (i = 1; i <= 100; i++) {
    type[i] = (int)reacparam[i][1];
    n1[i] = (int)reacparam[i][2];
    n2[i] = (int)reacparam[i][3];
    n3[i] = (int)reacparam[i][4];
    n4[i] = (int)reacparam[i][5];
    n5[i] = (int)reacparam[i][6];
    n6[i] = (int)reacparam[i][7];
    rev[i] = reacparam[i][8];
    q9[i] = reacparam[i][9];
  }
  for (i = 1; i <= 26; i++)
    for (j = 1; j <= 26; j++)
      a[i][j] = 0.;
  for (n = 1; n <= 100; n++) {
    ind = type[n];
    i = n1[n];
    j = n2[n];
    g = n3[n];
    h = n4[n];
    k = n5[n];
    l = n6[n];
    if (i <= 26 && l <= 26) {
      rn1 = nn1[ind];
      rn2 = nn2[ind];
      rn3 = nn3[ind];
      rn4 = nn4[ind];
      rn5 = nn5[ind];
      rn6 = nn6[ind];
      switch (ind) {
      case 0: {
        cn1 = f[n];
        cn2 = 0.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = 0.;
        cn6 = r[n];
        break;
      }
      case 1: {
        r[n] = rev[n] * 0.987e10 * pow(T, 1.5) * exp(-q9[n] / T) * f[n];
        f[n] = rhob * f[n];
        cn1 = Y[j] * f[n] / 2.;
        cn2 = Y[i] * f[n] / 2.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = 0.;
        cn6 = r[n];
        break;
      }
      case 2: {
        f[n] = rhob * f[n];
        r[n] = rev[n] * exp(-q9[n] / T) * f[n];
        cn1 = Y[j] * f[n] / 2.;
        cn2 = Y[i] * f[n] / 2.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = Y[l] * r[n] / 2.;
        cn6 = Y[k] * r[n] / 2.;
        break;
      }
      case 3: {
        cn1 = f[n];
        cn2 = 0.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = 0.;
        cn6 = Y[l] * r[n] / 2.;
        break;
      }
      case 4: {
        f[n] = rhob * f[n];
        r[n] = rev[n] * exp(-q9[n] / T) * f[n];
        cn1 = Y[j] * f[n] / 2.;
        cn2 = Y[i] * f[n] / 2.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = 0.;
        cn6 = Y[l] * r[n] / 2.;
        break;
      }
      case 5: {
        f[n] = rhob * f[n];
        r[n] = rev[n] * exp(-q9[n] / T) * f[n];
        cn1 = Y[i] * f[n] / 2.;
        cn2 = 0.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = Y[l] * r[n] / 2.;
        cn6 = Y[k] * r[n] / 2.;
        break;
      }
      case 6: {
        r[n] = rev[n] * 0.974e20 * pow(T, 1.5) * pow(T, 1.5) * exp(-q9[n] / T) *
               f[n];
        f[n] = rhob * rhob * f[n];
        cn1 = Y[i] * Y[i] * f[n] / 6.;
        cn2 = 0.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = 0.;
        cn6 = r[n];
        break;
      }
      case 7: {
        r[n] = rev[n] * 0.974e20 * pow(T, 1.5) * pow(T, 1.5) * exp(-q9[n] / T) *
               f[n];
        f[n] = rhob * rhob * f[n];
        cn1 = Y[j] * Y[i] * f[n] / 3.;
        cn2 = Y[i] * Y[i] * f[n] / 6.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = 0.;
        cn6 = r[n];
        break;
      }
      case 8: {
        f[n] = rhob * f[n];
        r[n] =
            rev[n] * 1.013e-10 * pow(T, -1.5) * rhob * exp(-q9[n] / T) * f[n];
        cn1 = Y[j] * f[n] / 2.;
        cn2 = Y[i] * f[n] / 2.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = Y[l] * Y[l] * r[n] / 6.;
        cn6 = Y[k] * Y[l] * r[n] / 3.;
        break;
      }
      case 9: {
        f[n] = rhob * f[n];
        r[n] =
            rev[n] * 1.013e-10 * pow(T, -1.5) * rhob * exp(-q9[n] / T) * f[n];
        cn1 = Y[j] * f[n] / 2.;
        cn2 = Y[i] * f[n] / 2.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = 0.;
        cn6 = Y[l] * Y[l] * r[n] / 6.;
        break;
      }
      case 10: {
        f[n] = rhob * f[n];
        r[n] =
            rev[n] * 1.013e-10 * pow(T, -1.5) * rhob * exp(-q9[n] / T) * f[n];
        cn1 = Y[i] * f[n] / 2.;
        cn2 = 0.;
        cn3 = 0.;
        cn4 = 0.;
        cn5 = Y[l] * Y[k] * r[n] / 3.;
        cn6 = Y[k] * Y[k] * r[n] / 6.;
        break;
      }
      case 11: {
        f[n] = rhob * f[n];
        r[n] =
            rev[n] * 1.013e-10 * pow(T, -1.5) * rhob * exp(-q9[n] / T) * f[n];
        cn1 = Y[j] * f[n] / 2.;
        cn2 = Y[i] * f[n] / 2.;
        cn3 = 0.;
        cn4 = Y[k] * Y[l] * r[n] / 3.;
        cn5 = Y[h] * Y[l] * r[n] / 3.;
        cn6 = Y[h] * Y[k] * r[n] / 3.;
      }
      }
      i = 26 + 1 - i;
      j = 26 + 1 - j;
      g = 26 + 1 - g;
      h = 26 + 1 - h;
      k = 26 + 1 - k;
      l = 26 + 1 - l;
      a[i][i] += rn1 * cn1;
      if (j <= 26)
        a[j][i] += rn2 * cn1;
      if (g <= 26)
        a[g][i] += rn3 * cn1;
      if (h <= 26)
        a[h][i] -= rn4 * cn1;
      if (k <= 26)
        a[k][i] -= rn5 * cn1;
      a[l][i] -= rn6 * cn1;
      if (j <= 26) {
        a[i][j] += rn1 * cn2;
        a[j][j] += rn2 * cn2;
        if (g <= 26)
          a[g][j] += rn3 * cn2;
        if (h <= 26)
          a[h][j] -= rn4 * cn2;
        if (k <= 26)
          a[k][j] -= rn5 * cn2;
        a[l][j] -= rn6 * cn2;
      }
      if (g <= 26) {
        a[i][g] += rn1 * cn3;
        if (j <= 26)
          a[j][g] += rn2 * cn3;
        a[g][g] += rn3 * cn3;
        if (h <= 26)
          a[h][g] -= rn4 * cn3;
        if (k <= 26)
          a[k][g] -= rn5 * cn3;
        a[l][g] -= rn6 * cn3;
      }
      if (h <= 26) {
        a[i][h] -= rn1 * cn4;
        if (j <= 26)
          a[j][h] -= rn2 * cn4;
        if (g <= 26)
          a[g][h] -= rn3 * cn4;
        a[h][h] += rn4 * cn4;
        if (k <= 26)
          a[k][h] += rn5 * cn4;
        a[l][h] += rn6 * cn4;
      }
      if (k <= 26) {
        a[i][k] -= rn1 * cn5;
        if (j <= 26)
          a[j][k] -= rn2 * cn5;
        if (g <= 26)
          a[g][k] -= rn3 * cn5;
        if (h <= 26)
          a[h][k] += rn4 * cn5;
        a[k][k] += rn5 * cn5;
        a[l][k] += rn6 * cn5;
      }
      a[i][l] -= rn1 * cn6;
      if (j <= 26)
        a[j][l] -= rn2 * cn6;
      if (g <= 26)
        a[g][l] -= rn3 * cn6;
      if (h <= 26)
        a[h][l] += rn4 * cn6;
      if (k <= 26)
        a[k][l] += rn5 * cn6;
      a[l][l] += rn6 * cn6;
    }
  }
  bdln = H * 3. * 1.e-5;
  for (i = 1; i <= 26; i++) {
    i1 = 26 + 1 - i;
    for (j = 1; j <= 26; j++) {
      j1 = 26 + 1 - j;
      if (fabs(a[j][i]) < bdln * Y0[j1] / Y0[i1])
        a[j][i] = 0.;
      else
        a[j][i] *= dt;
    }
    a[i][i] += 1.;
    b[i1] = Y0[i];
  }
  if (loop == 1)
    icnvm = ip;
  else
    icnvm = c0;
  nord = 0;
  fail = 0;
  for (i = 1; i <= 26; i++) {
    x[i] = b[i];
    yx[i] = 0.;
  }
  if (icnvm == inc)
    for (i = 1; i <= 26; i++)
      for (j = 1; j <= 26; j++)
        a0[j][i] = a[j][i];
  for (i = 1; i <= 26; i++) {
    if (a[i][i] == 0.) {
      fail = i;
      return fail;
    }
    for (j = i + 1; j <= 26; j++) {
      if (a[j][i] != 0.) {
        cx = a[j][i] / a[i][i];
        for (k = i + 1; k <= 26; k++)
          a[j][k] -= cx * a[i][k];
        a[j][i] = cx;
        x[j] -= cx * x[i];
      }
    }
  }
  do {
    x[26] /= a[26][26];
    yx[26] += x[26];
    for (i = 26 - 1; i >= 1; i--) {
      sum = 0.;
      for (j = i + 1; j <= 26; j++)
        sum += a[i][j] * x[j];
      x[i] = (x[i] - sum) / a[i][i];
      yx[i] += x[i];
    }
    test = 1;
    if (icnvm == inc) {
      for (i = 1; i <= 26; i++) {
        if (yx[i] != 0.) {
          xdy = fabs(x[i] / yx[i]);
          if (xdy > 2.e-4) {
            if (nord < 1) {
              nord++;
              for (j = 1; j <= 26; j++) {
                t = 0.;
                for (k = 1; k <= 26; k++)
                  t += a0[j][k] * yx[k];
                x[j] = b[j] - t;
              }
              for (j = 2; j <= 26; j++)
                for (k = j + 1; k <= 26; k++)
                  x[k] -= a[k][j] * x[j];
              break;
            } else {
              fail = -1;
              return fail;
            }
          } else
            test = 0;
        } else
          test = 0;
      }
    } else
      test = 0;
  } while (test);
  for (i = 1; i <= 26; i++) {
    yY[i] = yx[26 + 1 - i];
    dY_dt[i] = (yY[i] - Y0[i]) / dt;
  }
  return fail;
}


x86 assembly (clang, -O0):
<linearize>:
push   %rbp
mov    %rsp,%rbp
sub    $0x46d0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
movsd  %xmm0,-0x10(%rbp)
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %ecx,-0x2c(%rbp)
mov    %r8d,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
lea    -0xb0(%rbp),%rdi
lea    0x2f10(%rip),%rsi
mov    $0x60,%edx
call   1040 <memcpy@plt>
lea    -0x110(%rbp),%rdi
lea    0x2f58(%rip),%rsi
mov    $0x60,%edx
call   1040 <memcpy@plt>
lea    -0x170(%rbp),%rdi
xor    %esi,%esi
mov    $0x60,%edx
call   1030 <memset@plt>
lea    -0x1d0(%rbp),%rdi
xor    %esi,%esi
mov    $0x60,%edx
call   1030 <memset@plt>
movsd  0x2e20(%rip),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
lea    -0x230(%rbp),%rdi
xor    %esi,%esi
mov    $0x60,%edx
call   1030 <memset@plt>
movsd  0x2dfd(%rip),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  0x2ded(%rip),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  0x2ddd(%rip),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  0x2dd5(%rip),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  0x2dbd(%rip),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
lea    -0x290(%rbp),%rdi
lea    0x2f07(%rip),%rsi
mov    $0x60,%edx
call   1040 <memcpy@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
movl   $0x0,-0x404(%rbp)
movl   $0x1,-0x294(%rbp)
cmpl   $0x64,-0x294(%rbp)
jg     142b <linearize+0x2eb>
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x8(%rax),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0x5a0(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x10(%rax),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0x740(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x18(%rax),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0x8e0(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x20(%rax),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0xa80(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x28(%rax),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0xc20(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x30(%rax),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0xdc0(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x38(%rax),%ecx
movslq -0x294(%rbp),%rax
mov    %ecx,-0xf60(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x40(%rax),%xmm0
movslq -0x294(%rbp),%rax
movsd  %xmm0,-0x1290(%rbp,%rax,8)
ff ff
mov    -0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x48(%rax),%xmm0
movslq -0x294(%rbp),%rax
movsd  %xmm0,-0x15c0(%rbp,%rax,8)
ff ff
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    12b9 <linearize+0x179>
movl   $0x1,-0x294(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     14ad <linearize+0x36d>
movl   $0x1,-0x298(%rbp)
cmpl   $0x1a,-0x298(%rbp)
jg     1494 <linearize+0x354>
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
jmp    144c <linearize+0x30c>
jmp    1499 <linearize+0x359>
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    1435 <linearize+0x2f5>
movl   $0x1,-0x2ac(%rbp)
cmpl   $0x64,-0x2ac(%rbp)
jg     33ce <linearize+0x228e>
movslq -0x2ac(%rbp),%rax
mov    -0x5a0(%rbp,%rax,4),%eax
mov    %eax,-0x2b8(%rbp)
movslq -0x2ac(%rbp),%rax
mov    -0x740(%rbp,%rax,4),%eax
mov    %eax,-0x294(%rbp)
movslq -0x2ac(%rbp),%rax
mov    -0x8e0(%rbp,%rax,4),%eax
mov    %eax,-0x298(%rbp)
movslq -0x2ac(%rbp),%rax
mov    -0xa80(%rbp,%rax,4),%eax
mov    %eax,-0x29c(%rbp)
movslq -0x2ac(%rbp),%rax
mov    -0xc20(%rbp,%rax,4),%eax
mov    %eax,-0x2a0(%rbp)
movslq -0x2ac(%rbp),%rax
mov    -0xdc0(%rbp,%rax,4),%eax
mov    %eax,-0x2a4(%rbp)
movslq -0x2ac(%rbp),%rax
mov    -0xf60(%rbp,%rax,4),%eax
mov    %eax,-0x2a8(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     33b5 <linearize+0x2275>
cmpl   $0x1a,-0x2a8(%rbp)
jg     33b5 <linearize+0x2275>
movslq -0x2b8(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x2f0(%rbp)
ff
movslq -0x2b8(%rbp),%rax
movsd  -0x110(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x2f8(%rbp)
ff
movslq -0x2b8(%rbp),%rax
movsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x300(%rbp)
ff
movslq -0x2b8(%rbp),%rax
movsd  -0x1d0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x308(%rbp)
ff
movslq -0x2b8(%rbp),%rax
movsd  -0x230(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x310(%rbp)
ff
movslq -0x2b8(%rbp),%rax
movsd  -0x290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x318(%rbp)
ff
mov    -0x2b8(%rbp),%eax
mov    %rax,-0x4630(%rbp)
sub    $0xb,%rax
ja     2755 <linearize+0x1615>
mov    -0x4630(%rbp),%rax
lea    0x2a51(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movslq -0x2ac(%rbp),%rax
movsd  0x29b8(%rip),%xmm0
mulsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x4640(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x298a(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x4640(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x4638(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x4638(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2889(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2855(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2ac(%rbp),%rax
movsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x4648(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x4648(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2746(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2712(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x26c8(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2694(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2617(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2ac(%rbp),%rax
movsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x4650(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x4650(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2541(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x250d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x24b8(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2ac(%rbp),%rax
movsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x4658(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x4658(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x23e2(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x238d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2359(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movslq -0x2ac(%rbp),%rax
movsd  0x2379(%rip),%xmm0
mulsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x4670(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x2353(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x4670(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x4668(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x232a(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x4668(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x4660(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x4660(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2244(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movslq -0x2ac(%rbp),%rax
movsd  0x21f0(%rip),%xmm0
mulsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x4688(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x21ca(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x4688(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x4680(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x21a1(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x4680(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x4678(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x4678(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x209b(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x2077(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e8(%rbp)
jmp    2755 <linearize+0x1615>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2ac(%rbp),%rax
movsd  0x1ff1(%rip),%xmm0
mulsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x4698(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x1fcb(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x4698(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x4690(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x4690(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1f02(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1ece(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1ea4(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1e40(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2ac(%rbp),%rax
movsd  0x1e13(%rip),%xmm0
mulsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x46a8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x1ded(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x46a8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x46a0(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x46a0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1d24(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1cf0(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1cbb(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2ac(%rbp),%rax
movsd  0x1c6e(%rip),%xmm0
mulsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x46b8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x1c48(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x46b8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x46b0(%rbp)
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x46b0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1b7f(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1b2a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1b06(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
jmp    2755 <linearize+0x1615>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2ac(%rbp),%rax
movsd  0x1ab9(%rip),%xmm0
mulsd  -0x1290(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x46c8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x1a93(%rip),%xmm1
call   1060 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x46c8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x46c0(%rbp)
ff
movslq -0x2ac(%rbp),%rax
movsd  -0x15c0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x10(%rbp),%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x46c0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x19ca(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1996(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1957(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1913(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2a4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2ac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x18cf(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
mov    $0x1b,%eax
sub    -0x294(%rbp),%eax
mov    %eax,-0x294(%rbp)
mov    $0x1b,%eax
sub    -0x298(%rbp),%eax
mov    %eax,-0x298(%rbp)
mov    $0x1b,%eax
sub    -0x29c(%rbp),%eax
mov    %eax,-0x29c(%rbp)
mov    $0x1b,%eax
sub    -0x2a0(%rbp),%eax
mov    %eax,-0x2a0(%rbp)
mov    $0x1b,%eax
sub    -0x2a4(%rbp),%eax
mov    %eax,-0x2a4(%rbp)
mov    $0x1b,%eax
sub    -0x2a8(%rbp),%eax
mov    %eax,-0x2a8(%rbp)
movsd  -0x2f0(%rbp),%xmm0
ff
movsd  -0x2c0(%rbp),%xmm2
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x298(%rbp)
jg     284a <linearize+0x170a>
movsd  -0x2f8(%rbp),%xmm0
ff
movsd  -0x2c0(%rbp),%xmm2
ff
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x29c(%rbp)
jg     2898 <linearize+0x1758>
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2c0(%rbp),%xmm2
ff
movslq -0x29c(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a0(%rbp)
jg     28fd <linearize+0x17bd>
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x2c0(%rbp),%xmm2
ff
movslq -0x2a0(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a4(%rbp)
jg     2962 <linearize+0x1822>
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x2c0(%rbp),%xmm2
ff
movslq -0x2a4(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x318(%rbp),%xmm0
ff
movsd  -0x2c0(%rbp),%xmm2
ff
movslq -0x2a8(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x298(%rbp)
jg     2bb9 <linearize+0x1a79>
movsd  -0x2f0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x2f8(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x29c(%rbp)
jg     2a97 <linearize+0x1957>
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
movslq -0x29c(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a0(%rbp)
jg     2afc <linearize+0x19bc>
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
movslq -0x2a0(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a4(%rbp)
jg     2b61 <linearize+0x1a21>
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
movslq -0x2a4(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x318(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
movslq -0x2a8(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x29c(%rbp)
jg     2db8 <linearize+0x1c78>
movsd  -0x2f0(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x29c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x298(%rbp)
jg     2c55 <linearize+0x1b15>
movsd  -0x2f8(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x29c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movslq -0x29c(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x29c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a0(%rbp)
jg     2cfb <linearize+0x1bbb>
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movslq -0x2a0(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x29c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a4(%rbp)
jg     2d60 <linearize+0x1c20>
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movslq -0x2a4(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x29c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x318(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movslq -0x2a8(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x29c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a0(%rbp)
jg     2fb7 <linearize+0x1e77>
movsd  -0x2f0(%rbp),%xmm0
ff
movsd  -0x2d8(%rbp),%xmm2
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x298(%rbp)
jg     2e82 <linearize+0x1d42>
movsd  -0x2f8(%rbp),%xmm0
ff
movsd  -0x2d8(%rbp),%xmm2
ff
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x29c(%rbp)
jg     2ee7 <linearize+0x1da7>
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2d8(%rbp),%xmm2
ff
movslq -0x29c(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x2d8(%rbp),%xmm2
ff
movslq -0x2a0(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a4(%rbp)
jg     2f76 <linearize+0x1e36>
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x2d8(%rbp),%xmm2
ff
movslq -0x2a4(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x318(%rbp),%xmm0
ff
movsd  -0x2d8(%rbp),%xmm2
ff
movslq -0x2a8(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a4(%rbp)
jg     31b6 <linearize+0x2076>
movsd  -0x2f0(%rbp),%xmm0
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x298(%rbp)
jg     3081 <linearize+0x1f41>
movsd  -0x2f8(%rbp),%xmm0
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x29c(%rbp)
jg     30e6 <linearize+0x1fa6>
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movslq -0x29c(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a0(%rbp)
jg     3134 <linearize+0x1ff4>
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movslq -0x2a0(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movslq -0x2a4(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x318(%rbp),%xmm0
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movslq -0x2a8(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x2f0(%rbp),%xmm0
ff
movsd  -0x2e8(%rbp),%xmm2
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x298(%rbp)
jg     3273 <linearize+0x2133>
movsd  -0x2f8(%rbp),%xmm0
ff
movsd  -0x2e8(%rbp),%xmm2
ff
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x29c(%rbp)
jg     32d8 <linearize+0x2198>
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2e8(%rbp),%xmm2
ff
movslq -0x29c(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a0(%rbp)
jg     3326 <linearize+0x21e6>
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x2e8(%rbp),%xmm2
ff
movslq -0x2a0(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1a,-0x2a4(%rbp)
jg     3374 <linearize+0x2234>
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x2e8(%rbp),%xmm2
ff
movslq -0x2a4(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x318(%rbp),%xmm0
ff
movsd  -0x2e8(%rbp),%xmm2
ff
movslq -0x2a8(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    33ba <linearize+0x227a>
mov    -0x2ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ac(%rbp)
jmp    14b7 <linearize+0x377>
movsd  0xc42(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  0xc2d(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x400(%rbp)
ff
movl   $0x1,-0x294(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     3578 <linearize+0x2438>
mov    $0x1b,%eax
sub    -0x294(%rbp),%eax
mov    %eax,-0x2b0(%rbp)
movl   $0x1,-0x298(%rbp)
cmpl   $0x1a,-0x298(%rbp)
jg     3513 <linearize+0x23d3>
mov    $0x1b,%eax
sub    -0x298(%rbp),%eax
mov    %eax,-0x2b4(%rbp)
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbf6(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x400(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x2b4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2b0(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    34cc <linearize+0x238c>
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    34fa <linearize+0x23ba>
movsd  -0x40(%rbp),%xmm0
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    34ff <linearize+0x23bf>
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
jmp    3421 <linearize+0x22e1>
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  0xac6(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2b0(%rbp),%rax
movsd  %xmm0,-0x2d70(%rbp,%rax,8)
ff ff
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    33f9 <linearize+0x22b9>
cmpl   $0x1,-0x2c(%rbp)
jne    3590 <linearize+0x2450>
mov    -0x34(%rbp),%eax
mov    %eax,-0x2e54(%rbp)
jmp    359c <linearize+0x245c>
mov    -0x404(%rbp),%eax
mov    %eax,-0x2e54(%rbp)
movl   $0x0,-0x4624(%rbp)
movl   $0x0,-0x3f4(%rbp)
movl   $0x1,-0x294(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     360e <linearize+0x24ce>
movslq -0x294(%rbp),%rax
movsd  -0x2d70(%rbp,%rax,8),%xmm0
ff ff
movslq -0x294(%rbp),%rax
movsd  %xmm0,-0x2f30(%rbp,%rax,8)
ff ff
movslq -0x294(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e50(%rbp,%rax,8)
ff ff
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    35ba <linearize+0x247a>
mov    -0x2e54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    36c5 <linearize+0x2585>
movl   $0x1,-0x294(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     36c0 <linearize+0x2580>
movl   $0x1,-0x298(%rbp)
cmpl   $0x1a,-0x298(%rbp)
jg     36a7 <linearize+0x2567>
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x298(%rbp),%rcx
lea    -0x4600(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
jmp    363e <linearize+0x24fe>
jmp    36ac <linearize+0x256c>
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    3627 <linearize+0x24e7>
jmp    36c5 <linearize+0x2585>
movl   $0x1,-0x294(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     3927 <linearize+0x27e7>
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    372d <linearize+0x25ed>
jp     372d <linearize+0x25ed>
mov    -0x294(%rbp),%eax
mov    %eax,-0x3f4(%rbp)
mov    -0x3f4(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3de8 <linearize+0x2ca8>
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
cmpl   $0x1a,-0x298(%rbp)
jg     390e <linearize+0x27ce>
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    3785 <linearize+0x2645>
jp     3785 <linearize+0x2645>
jmp    38f5 <linearize+0x27b5>
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x4608(%rbp)
ff
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a4(%rbp)
cmpl   $0x1a,-0x2a4(%rbp)
jg     3879 <linearize+0x2739>
movsd  -0x4608(%rbp),%xmm0
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a4(%rbp)
jmp    37e4 <linearize+0x26a4>
movsd  -0x4608(%rbp),%xmm0
ff
movslq -0x298(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x4608(%rbp),%xmm0
ff
movslq -0x294(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm2
ff ff
movslq -0x298(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2f30(%rbp,%rax,8)
ff ff
jmp    38fa <linearize+0x27ba>
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
jmp    373c <linearize+0x25fc>
jmp    3913 <linearize+0x27d3>
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    36cf <linearize+0x258f>
jmp    392c <linearize+0x27ec>
movsd  -0x15d0(%rbp),%xmm1
ff
movsd  -0x2e60(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e60(%rbp)
ff
movsd  -0x2e60(%rbp),%xmm0
ff
addsd  -0x2d80(%rbp),%xmm0
ff
movsd  %xmm0,-0x2d80(%rbp)
ff
movl   $0x19,-0x294(%rbp)
cmpl   $0x1,-0x294(%rbp)
jl     3a87 <linearize+0x2947>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x4610(%rbp)
ff
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
cmpl   $0x1a,-0x298(%rbp)
jg     39fe <linearize+0x28be>
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x298(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x4610(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x4610(%rbp)
ff
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
jmp    3991 <linearize+0x2851>
movslq -0x294(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm0
ff ff
subsd  -0x4610(%rbp),%xmm0
ff
movslq -0x294(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x294(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movslq -0x294(%rbp),%rax
movsd  %xmm0,-0x2f30(%rbp,%rax,8)
ff ff
movslq -0x294(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x294(%rbp),%rax
addsd  -0x2e50(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x2e50(%rbp,%rax,8)
ff ff
mov    -0x294(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x294(%rbp)
jmp    396a <linearize+0x282a>
movl   $0x1,-0x4628(%rbp)
mov    -0x2e54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    3d3d <linearize+0x2bfd>
movl   $0x1,-0x294(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     3d38 <linearize+0x2bf8>
movslq -0x294(%rbp),%rax
movsd  -0x2e50(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    3adf <linearize+0x299f>
jp     3adf <linearize+0x299f>
jmp    3d15 <linearize+0x2bd5>
movslq -0x294(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x294(%rbp),%rax
divsd  -0x2e50(%rbp,%rax,8),%xmm0
ff ff
movaps 0x55a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x4618(%rbp)
ff
movsd  -0x4618(%rbp),%xmm0
ff
movsd  0x4fe(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    3d06 <linearize+0x2bc6>
cmpl   $0x1,-0x4624(%rbp)
jge    3cee <linearize+0x2bae>
mov    -0x4624(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4624(%rbp)
movl   $0x1,-0x298(%rbp)
cmpl   $0x1a,-0x298(%rbp)
jg     3c1d <linearize+0x2add>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x4620(%rbp)
ff
movl   $0x1,-0x2a4(%rbp)
cmpl   $0x1a,-0x2a4(%rbp)
jg     3be1 <linearize+0x2aa1>
movslq -0x298(%rbp),%rcx
lea    -0x4600(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2a4(%rbp),%rax
movsd  -0x2e50(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x4620(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x4620(%rbp)
ff
mov    -0x2a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a4(%rbp)
jmp    3b74 <linearize+0x2a34>
movslq -0x298(%rbp),%rax
movsd  -0x2d70(%rbp,%rax,8),%xmm0
ff ff
subsd  -0x4620(%rbp),%xmm0
ff
movslq -0x298(%rbp),%rax
movsd  %xmm0,-0x2f30(%rbp,%rax,8)
ff ff
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
jmp    3b52 <linearize+0x2a12>
movl   $0x2,-0x298(%rbp)
cmpl   $0x1a,-0x298(%rbp)
jg     3ce9 <linearize+0x2ba9>
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a4(%rbp)
cmpl   $0x1a,-0x2a4(%rbp)
jg     3cd0 <linearize+0x2b90>
movslq -0x2a4(%rbp),%rcx
lea    -0x2c90(%rbp),%rax
imul   $0xd8,%rcx,%rcx
add    %rcx,%rax
movslq -0x298(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x298(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm2
ff ff
movslq -0x2a4(%rbp),%rax
movsd  -0x2f30(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2f30(%rbp,%rax,8)
ff ff
mov    -0x2a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a4(%rbp)
jmp    3c43 <linearize+0x2b03>
jmp    3cd5 <linearize+0x2b95>
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
jmp    3c27 <linearize+0x2ae7>
jmp    3d38 <linearize+0x2bf8>
movl   $0xffffffff,-0x3f4(%rbp)
ff ff ff
mov    -0x3f4(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3de8 <linearize+0x2ca8>
movl   $0x0,-0x4628(%rbp)
jmp    3d1f <linearize+0x2bdf>
movl   $0x0,-0x4628(%rbp)
jmp    3d24 <linearize+0x2be4>
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    3aaa <linearize+0x296a>
jmp    3d47 <linearize+0x2c07>
movl   $0x0,-0x4628(%rbp)
jmp    3d4c <linearize+0x2c0c>
cmpl   $0x0,-0x4628(%rbp)
jne    392c <linearize+0x27ec>
movl   $0x1,-0x294(%rbp)
cmpl   $0x1a,-0x294(%rbp)
jg     3ddf <linearize+0x2c9f>
mov    $0x1b,%eax
sub    -0x294(%rbp),%eax
cltq
movsd  -0x2e50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x294(%rbp),%rax
movsd  %xmm0,-0x3f0(%rbp,%rax,8)
ff ff
movslq -0x294(%rbp),%rax
movsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    0x10(%rbp),%rax
movslq -0x294(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x294(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    3d63 <linearize+0x2c23>
mov    -0x3f4(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x46d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<linearize>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x43b8,%rsp
movsd  %xmm3,0x30(%rsp)
movapd %xmm2,0x80(%rsp)
movapd %xmm1,0x90(%rsp)
mov    %r9d,0x7c(%rsp)
mov    %r8d,0x74(%rsp)
mov    %ecx,0x78(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x38(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    0x43f0(%rsp),%rbp
xorps  %xmm0,%xmm0
movaps %xmm0,0x370(%rsp)
movaps %xmm0,0x360(%rsp)
movaps %xmm0,0x350(%rsp)
movaps %xmm0,0x340(%rsp)
movaps %xmm0,0x330(%rsp)
movaps %xmm0,0x320(%rsp)
movaps %xmm0,0x310(%rsp)
movaps %xmm0,0x300(%rsp)
movaps %xmm0,0x2f0(%rsp)
movaps %xmm0,0x2e0(%rsp)
movaps %xmm0,0x2d0(%rsp)
movaps %xmm0,0x2c0(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x318(%rsp)
movaps %xmm0,0x190(%rsp)
movaps %xmm0,0x1a0(%rsp)
movaps %xmm0,0x1c0(%rsp)
movaps %xmm0,0x1b0(%rsp)
movaps %xmm0,0x180(%rsp)
mov    %rax,0x190(%rsp)
mov    %rax,0x1a8(%rsp)
mov    %rax,0x1c0(%rsp)
movaps 0x2dc5(%rip),%xmm0
movaps %xmm0,0x1d0(%rsp)
add    $0xe8,%rdi
xor    %eax,%eax
nopl   0x0(%rax)
movsd  -0x90(%rdi),%xmm0
ff
movhpd -0x40(%rdi),%xmm0
cvttpd2dq %xmm0,%xmm0
movlpd %xmm0,0x2b54(%rsp,%rax,1)
movsd  -0x88(%rdi),%xmm0
ff
movhpd -0x38(%rdi),%xmm0
cvttpd2dq %xmm0,%xmm0
movlpd %xmm0,0x29b4(%rsp,%rax,1)
movsd  -0x80(%rdi),%xmm0
movhpd -0x30(%rdi),%xmm0
cvttpd2dq %xmm0,%xmm0
movlpd %xmm0,0x2814(%rsp,%rax,1)
movsd  -0x78(%rdi),%xmm0
movhpd -0x28(%rdi),%xmm0
cvttpd2dq %xmm0,%xmm0
movlpd %xmm0,0x2674(%rsp,%rax,1)
movsd  -0x70(%rdi),%xmm0
movhpd -0x20(%rdi),%xmm0
cvttpd2dq %xmm0,%xmm0
movlpd %xmm0,0x24d4(%rsp,%rax,1)
movsd  -0x68(%rdi),%xmm0
movhpd -0x18(%rdi),%xmm0
cvttpd2dq %xmm0,%xmm0
movlpd %xmm0,0x2334(%rsp,%rax,1)
movsd  -0x60(%rdi),%xmm0
movhpd -0x10(%rdi),%xmm0
cvttpd2dq %xmm0,%xmm0
movlpd %xmm0,0x2194(%rsp,%rax,1)
movsd  -0x58(%rdi),%xmm0
movhps -0x8(%rdi),%xmm0
movups %xmm0,0x1e68(%rsp,%rax,2)
movsd  -0x50(%rdi),%xmm0
movhps (%rdi),%xmm0
movups %xmm0,0x1b38(%rsp,%rax,2)
add    $0xa0,%rdi
add    $0x8,%rax
cmp    $0x190,%rax
jne    1250 <linearize+0x120>
xorps  %xmm0,%xmm0
movaps %xmm0,0x520(%rsp)
movaps %xmm0,0x510(%rsp)
movaps %xmm0,0x500(%rsp)
movaps %xmm0,0x4f0(%rsp)
movaps %xmm0,0x4e0(%rsp)
movaps %xmm0,0x4d0(%rsp)
movaps %xmm0,0x4c0(%rsp)
movaps %xmm0,0x4b0(%rsp)
movaps %xmm0,0x4a0(%rsp)
movaps %xmm0,0x490(%rsp)
movaps %xmm0,0x480(%rsp)
movaps %xmm0,0x470(%rsp)
movaps %xmm0,0x460(%rsp)
movups %xmm0,0x538(%rsp)
movups %xmm0,0x548(%rsp)
movups %xmm0,0x558(%rsp)
movups %xmm0,0x568(%rsp)
movups %xmm0,0x578(%rsp)
movups %xmm0,0x588(%rsp)
movups %xmm0,0x598(%rsp)
movups %xmm0,0x5a8(%rsp)
movups %xmm0,0x5b8(%rsp)
movups %xmm0,0x5c8(%rsp)
movups %xmm0,0x5d8(%rsp)
movups %xmm0,0x5e8(%rsp)
movups %xmm0,0x5f8(%rsp)
movaps %xmm0,0x6d0(%rsp)
movaps %xmm0,0x6c0(%rsp)
movaps %xmm0,0x6b0(%rsp)
movaps %xmm0,0x6a0(%rsp)
movaps %xmm0,0x690(%rsp)
movaps %xmm0,0x680(%rsp)
movaps %xmm0,0x670(%rsp)
movaps %xmm0,0x660(%rsp)
movaps %xmm0,0x650(%rsp)
movaps %xmm0,0x640(%rsp)
movaps %xmm0,0x630(%rsp)
movaps %xmm0,0x620(%rsp)
movaps %xmm0,0x610(%rsp)
movups %xmm0,0x7a8(%rsp)
movups %xmm0,0x798(%rsp)
movups %xmm0,0x788(%rsp)
movups %xmm0,0x778(%rsp)
movups %xmm0,0x768(%rsp)
movups %xmm0,0x758(%rsp)
movups %xmm0,0x748(%rsp)
movups %xmm0,0x738(%rsp)
movups %xmm0,0x728(%rsp)
movups %xmm0,0x718(%rsp)
movups %xmm0,0x708(%rsp)
movups %xmm0,0x6f8(%rsp)
movups %xmm0,0x6e8(%rsp)
movaps %xmm0,0x880(%rsp)
movaps %xmm0,0x870(%rsp)
movaps %xmm0,0x860(%rsp)
movaps %xmm0,0x850(%rsp)
movaps %xmm0,0x840(%rsp)
movaps %xmm0,0x830(%rsp)
movaps %xmm0,0x820(%rsp)
movaps %xmm0,0x810(%rsp)
movaps %xmm0,0x800(%rsp)
movaps %xmm0,0x7f0(%rsp)
movaps %xmm0,0x7e0(%rsp)
movaps %xmm0,0x7d0(%rsp)
movaps %xmm0,0x7c0(%rsp)
movups %xmm0,0x958(%rsp)
movups %xmm0,0x948(%rsp)
movups %xmm0,0x938(%rsp)
movups %xmm0,0x928(%rsp)
movups %xmm0,0x918(%rsp)
movups %xmm0,0x908(%rsp)
movups %xmm0,0x8f8(%rsp)
movups %xmm0,0x8e8(%rsp)
movups %xmm0,0x8d8(%rsp)
movups %xmm0,0x8c8(%rsp)
movups %xmm0,0x8b8(%rsp)
movups %xmm0,0x8a8(%rsp)
movups %xmm0,0x898(%rsp)
movaps %xmm0,0xa30(%rsp)
movaps %xmm0,0xa20(%rsp)
movaps %xmm0,0xa10(%rsp)
movaps %xmm0,0xa00(%rsp)
movaps %xmm0,0x9f0(%rsp)
movaps %xmm0,0x9e0(%rsp)
movaps %xmm0,0x9d0(%rsp)
movaps %xmm0,0x9c0(%rsp)
movaps %xmm0,0x9b0(%rsp)
movaps %xmm0,0x9a0(%rsp)
movaps %xmm0,0x990(%rsp)
movaps %xmm0,0x980(%rsp)
movaps %xmm0,0x970(%rsp)
movups %xmm0,0xb08(%rsp)
movups %xmm0,0xaf8(%rsp)
movups %xmm0,0xae8(%rsp)
movups %xmm0,0xad8(%rsp)
movups %xmm0,0xac8(%rsp)
movups %xmm0,0xab8(%rsp)
movups %xmm0,0xaa8(%rsp)
movups %xmm0,0xa98(%rsp)
movups %xmm0,0xa88(%rsp)
movups %xmm0,0xa78(%rsp)
movups %xmm0,0xa68(%rsp)
movups %xmm0,0xa58(%rsp)
movups %xmm0,0xa48(%rsp)
movaps %xmm0,0xbe0(%rsp)
movaps %xmm0,0xbd0(%rsp)
movaps %xmm0,0xbc0(%rsp)
movaps %xmm0,0xbb0(%rsp)
movaps %xmm0,0xba0(%rsp)
movaps %xmm0,0xb90(%rsp)
movaps %xmm0,0xb80(%rsp)
movaps %xmm0,0xb70(%rsp)
movaps %xmm0,0xb60(%rsp)
movaps %xmm0,0xb50(%rsp)
movaps %xmm0,0xb40(%rsp)
movaps %xmm0,0xb30(%rsp)
movaps %xmm0,0xb20(%rsp)
movups %xmm0,0xcb8(%rsp)
movups %xmm0,0xca8(%rsp)
movups %xmm0,0xc98(%rsp)
movups %xmm0,0xc88(%rsp)
movups %xmm0,0xc78(%rsp)
movups %xmm0,0xc68(%rsp)
movups %xmm0,0xc58(%rsp)
movups %xmm0,0xc48(%rsp)
movups %xmm0,0xc38(%rsp)
movups %xmm0,0xc28(%rsp)
movups %xmm0,0xc18(%rsp)
movups %xmm0,0xc08(%rsp)
movups %xmm0,0xbf8(%rsp)
movaps %xmm0,0xd90(%rsp)
movaps %xmm0,0xd80(%rsp)
movaps %xmm0,0xd70(%rsp)
movaps %xmm0,0xd60(%rsp)
movaps %xmm0,0xd50(%rsp)
movaps %xmm0,0xd40(%rsp)
movaps %xmm0,0xd30(%rsp)
movaps %xmm0,0xd20(%rsp)
movaps %xmm0,0xd10(%rsp)
movaps %xmm0,0xd00(%rsp)
movaps %xmm0,0xcf0(%rsp)
movaps %xmm0,0xce0(%rsp)
movaps %xmm0,0xcd0(%rsp)
movups %xmm0,0xe68(%rsp)
movups %xmm0,0xe58(%rsp)
movups %xmm0,0xe48(%rsp)
movups %xmm0,0xe38(%rsp)
movups %xmm0,0xe28(%rsp)
movups %xmm0,0xe18(%rsp)
movups %xmm0,0xe08(%rsp)
movups %xmm0,0xdf8(%rsp)
movups %xmm0,0xde8(%rsp)
movups %xmm0,0xdd8(%rsp)
movups %xmm0,0xdc8(%rsp)
movups %xmm0,0xdb8(%rsp)
movups %xmm0,0xda8(%rsp)
movaps %xmm0,0xf40(%rsp)
movaps %xmm0,0xf30(%rsp)
movaps %xmm0,0xf20(%rsp)
movaps %xmm0,0xf10(%rsp)
movaps %xmm0,0xf00(%rsp)
movaps %xmm0,0xef0(%rsp)
movaps %xmm0,0xee0(%rsp)
movaps %xmm0,0xed0(%rsp)
movaps %xmm0,0xec0(%rsp)
movaps %xmm0,0xeb0(%rsp)
movaps %xmm0,0xea0(%rsp)
movaps %xmm0,0xe90(%rsp)
movaps %xmm0,0xe80(%rsp)
movups %xmm0,0x1018(%rsp)
movups %xmm0,0x1008(%rsp)
movups %xmm0,0xff8(%rsp)
movups %xmm0,0xfe8(%rsp)
movups %xmm0,0xfd8(%rsp)
movups %xmm0,0xfc8(%rsp)
movups %xmm0,0xfb8(%rsp)
movups %xmm0,0xfa8(%rsp)
movups %xmm0,0xf98(%rsp)
movups %xmm0,0xf88(%rsp)
movups %xmm0,0xf78(%rsp)
movups %xmm0,0xf68(%rsp)
movups %xmm0,0xf58(%rsp)
movaps %xmm0,0x10f0(%rsp)
movaps %xmm0,0x10e0(%rsp)
movaps %xmm0,0x10d0(%rsp)
movaps %xmm0,0x10c0(%rsp)
movaps %xmm0,0x10b0(%rsp)
movaps %xmm0,0x10a0(%rsp)
movaps %xmm0,0x1090(%rsp)
movaps %xmm0,0x1080(%rsp)
movaps %xmm0,0x1070(%rsp)
movaps %xmm0,0x1060(%rsp)
movaps %xmm0,0x1050(%rsp)
movaps %xmm0,0x1040(%rsp)
movaps %xmm0,0x1030(%rsp)
movups %xmm0,0x11c8(%rsp)
movups %xmm0,0x11b8(%rsp)
movups %xmm0,0x11a8(%rsp)
movups %xmm0,0x1198(%rsp)
movups %xmm0,0x1188(%rsp)
movups %xmm0,0x1178(%rsp)
movups %xmm0,0x1168(%rsp)
movups %xmm0,0x1158(%rsp)
movups %xmm0,0x1148(%rsp)
movups %xmm0,0x1138(%rsp)
movups %xmm0,0x1128(%rsp)
movups %xmm0,0x1118(%rsp)
movups %xmm0,0x1108(%rsp)
movaps %xmm0,0x12a0(%rsp)
movaps %xmm0,0x1290(%rsp)
movaps %xmm0,0x1280(%rsp)
movaps %xmm0,0x1270(%rsp)
movaps %xmm0,0x1260(%rsp)
movaps %xmm0,0x1250(%rsp)
movaps %xmm0,0x1240(%rsp)
movaps %xmm0,0x1230(%rsp)
movaps %xmm0,0x1220(%rsp)
movaps %xmm0,0x1210(%rsp)
movaps %xmm0,0x1200(%rsp)
movaps %xmm0,0x11f0(%rsp)
movaps %xmm0,0x11e0(%rsp)
movups %xmm0,0x1378(%rsp)
movups %xmm0,0x1368(%rsp)
movups %xmm0,0x1358(%rsp)
movups %xmm0,0x1348(%rsp)
movups %xmm0,0x1338(%rsp)
movups %xmm0,0x1328(%rsp)
movups %xmm0,0x1318(%rsp)
movups %xmm0,0x1308(%rsp)
movups %xmm0,0x12f8(%rsp)
movups %xmm0,0x12e8(%rsp)
movups %xmm0,0x12d8(%rsp)
movups %xmm0,0x12c8(%rsp)
movups %xmm0,0x12b8(%rsp)
movaps %xmm0,0x1450(%rsp)
movaps %xmm0,0x1440(%rsp)
movaps %xmm0,0x1430(%rsp)
movaps %xmm0,0x1420(%rsp)
movaps %xmm0,0x1410(%rsp)
movaps %xmm0,0x1400(%rsp)
movaps %xmm0,0x13f0(%rsp)
movaps %xmm0,0x13e0(%rsp)
movaps %xmm0,0x13d0(%rsp)
movaps %xmm0,0x13c0(%rsp)
movaps %xmm0,0x13b0(%rsp)
movaps %xmm0,0x13a0(%rsp)
movaps %xmm0,0x1390(%rsp)
movups %xmm0,0x1528(%rsp)
movups %xmm0,0x1518(%rsp)
movups %xmm0,0x1508(%rsp)
movups %xmm0,0x14f8(%rsp)
movups %xmm0,0x14e8(%rsp)
movups %xmm0,0x14d8(%rsp)
movups %xmm0,0x14c8(%rsp)
movups %xmm0,0x14b8(%rsp)
movups %xmm0,0x14a8(%rsp)
movups %xmm0,0x1498(%rsp)
movups %xmm0,0x1488(%rsp)
movups %xmm0,0x1478(%rsp)
movups %xmm0,0x1468(%rsp)
movaps %xmm0,0x1600(%rsp)
movaps %xmm0,0x15f0(%rsp)
movaps %xmm0,0x15e0(%rsp)
movaps %xmm0,0x15d0(%rsp)
movaps %xmm0,0x15c0(%rsp)
movaps %xmm0,0x15b0(%rsp)
movaps %xmm0,0x15a0(%rsp)
movaps %xmm0,0x1590(%rsp)
movaps %xmm0,0x1580(%rsp)
movaps %xmm0,0x1570(%rsp)
movaps %xmm0,0x1560(%rsp)
movaps %xmm0,0x1550(%rsp)
movaps %xmm0,0x1540(%rsp)
movups %xmm0,0x16d8(%rsp)
movups %xmm0,0x16c8(%rsp)
movups %xmm0,0x16b8(%rsp)
movups %xmm0,0x16a8(%rsp)
movups %xmm0,0x1698(%rsp)
movups %xmm0,0x1688(%rsp)
movups %xmm0,0x1678(%rsp)
movups %xmm0,0x1668(%rsp)
movups %xmm0,0x1658(%rsp)
movups %xmm0,0x1648(%rsp)
movups %xmm0,0x1638(%rsp)
movups %xmm0,0x1628(%rsp)
movups %xmm0,0x1618(%rsp)
movaps %xmm0,0x17b0(%rsp)
movaps %xmm0,0x17a0(%rsp)
movaps %xmm0,0x1790(%rsp)
movaps %xmm0,0x1780(%rsp)
movaps %xmm0,0x1770(%rsp)
movaps %xmm0,0x1760(%rsp)
movaps %xmm0,0x1750(%rsp)
movaps %xmm0,0x1740(%rsp)
movaps %xmm0,0x1730(%rsp)
movaps %xmm0,0x1720(%rsp)
movaps %xmm0,0x1710(%rsp)
movaps %xmm0,0x1700(%rsp)
movaps %xmm0,0x16f0(%rsp)
movups %xmm0,0x1888(%rsp)
movups %xmm0,0x1878(%rsp)
movups %xmm0,0x1868(%rsp)
movups %xmm0,0x1858(%rsp)
movups %xmm0,0x1848(%rsp)
movups %xmm0,0x1838(%rsp)
movups %xmm0,0x1828(%rsp)
movups %xmm0,0x1818(%rsp)
movups %xmm0,0x1808(%rsp)
movups %xmm0,0x17f8(%rsp)
movups %xmm0,0x17e8(%rsp)
movups %xmm0,0x17d8(%rsp)
movups %xmm0,0x17c8(%rsp)
movaps %xmm0,0x1960(%rsp)
movaps %xmm0,0x1950(%rsp)
movaps %xmm0,0x1940(%rsp)
movaps %xmm0,0x1930(%rsp)
movaps %xmm0,0x1920(%rsp)
movaps %xmm0,0x1910(%rsp)
movaps %xmm0,0x1900(%rsp)
movaps %xmm0,0x18f0(%rsp)
movaps %xmm0,0x18e0(%rsp)
movaps %xmm0,0x18d0(%rsp)
movaps %xmm0,0x18c0(%rsp)
movaps %xmm0,0x18b0(%rsp)
movaps %xmm0,0x18a0(%rsp)
movups %xmm0,0x1a38(%rsp)
movups %xmm0,0x1a28(%rsp)
movups %xmm0,0x1a18(%rsp)
movups %xmm0,0x1a08(%rsp)
movups %xmm0,0x19f8(%rsp)
movups %xmm0,0x19e8(%rsp)
movups %xmm0,0x19d8(%rsp)
movups %xmm0,0x19c8(%rsp)
movups %xmm0,0x19b8(%rsp)
movups %xmm0,0x19a8(%rsp)
movups %xmm0,0x1998(%rsp)
movups %xmm0,0x1988(%rsp)
movups %xmm0,0x1978(%rsp)
movsd  0x30(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x60(%rsp)
xorpd  %xmm12,%xmm12
xor    %r12d,%r12d
movapd 0x222d(%rip),%xmm11
xorpd  %xmm2,%xmm2
xorpd  %xmm10,%xmm10
xorpd  %xmm0,%xmm0
xorpd  %xmm9,%xmm9
xorpd  %xmm8,%xmm8
jmp    1e21 <linearize+0xcf1>
nopl   0x0(%rax)
mulsd  %xmm0,%xmm3
addsd  (%r10,%rdx,8),%xmm3
movsd  %xmm3,(%r10,%rdx,8)
add    $0x4,%r12
cmp    $0x190,%r12
je     3000 <linearize+0x1ed0>
movslq 0x29b4(%rsp,%r12,1),%r13
cmp    $0x1a,%r13
jg     1e10 <linearize+0xce0>
mov    0x2194(%rsp,%r12,1),%r14d
cmp    $0x1a,%r14d
jg     1e10 <linearize+0xce0>
movslq 0x2b54(%rsp,%r12,1),%r15
movslq 0x2814(%rsp,%r12,1),%rdx
movslq 0x2674(%rsp,%r12,1),%rax
mov    %rax,0x68(%rsp)
movslq 0x24d4(%rsp,%r12,1),%rax
mov    %rax,0x58(%rsp)
movslq 0x2334(%rsp,%r12,1),%rax
mov    %rax,0x50(%rsp)
movsd  0x320(%rsp,%r15,8),%xmm15
movsd  0x2c0(%rsp,%r15,8),%xmm14
movsd  0x180(%rsp,%r15,8),%xmm13
cmp    $0xb,%r15d
mov    %rdx,0x48(%rsp)
ja     2a30 <linearize+0x1900>
movslq %r14d,%rsi
mov    %r15d,%eax
lea    0x21e2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x38(%rsp),%rax
movsd  0x8(%rax,%r12,2),%xmm2
mov    0x40(%rsp),%rax
jmp    23cc <linearize+0x129c>
movsd  0x1e68(%rsp,%r12,2),%xmm0
mulsd  0x2189(%rip),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x216e(%rip),%xmm1
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  0x20e8(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x20b5(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
mulsd  (%rsp),%xmm0
mov    0x38(%rsp),%rcx
mulsd  0x8(%rcx,%r12,2),%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r12,2)
movsd  0x8(%rcx,%r12,2),%xmm10
mulsd  0x30(%rsp),%xmm10
movsd  %xmm10,0x8(%rcx,%r12,2)
mov    0x43f8(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm10,%xmm2
movsd  0x2091(%rip),%xmm0
mulsd  %xmm0,%xmm2
mulsd  (%rcx,%r13,8),%xmm10
mulsd  %xmm0,%xmm10
jmp    2502 <linearize+0x13d2>
mov    0x38(%rsp),%rbx
movsd  0x8(%rbx,%r12,2),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x1e68(%rsp,%r12,2),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  %xmm11,%xmm0
divsd  0x10(%rsp),%xmm0
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
mov    %rsi,(%rsp)
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1fc9(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
mulsd  0x8(%rsp),%xmm0
mulsd  0x8(%rbx,%r12,2),%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r12,2)
movsd  0x8(%rbx,%r12,2),%xmm10
mov    0x43f8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm10,%xmm2
movsd  0x1fb7(%rip),%xmm1
mulsd  %xmm1,%xmm2
mulsd  (%rax,%r13,8),%xmm10
mulsd  %xmm1,%xmm10
mov    (%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm9
mulsd  %xmm0,%xmm9
mulsd  %xmm1,%xmm9
mov    0x50(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
xorpd  %xmm8,%xmm8
jmp    2a30 <linearize+0x1900>
mov    0x38(%rsp),%rax
movsd  0x8(%rax,%r12,2),%xmm2
mov    0x43f8(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm0
mov    0x40(%rsp),%rax
mulsd  0x8(%rax,%r12,2),%xmm0
mulsd  0x1f4f(%rip),%xmm0
jmp    23d3 <linearize+0x12a3>
mov    0x38(%rsp),%rbx
movsd  0x8(%rbx,%r12,2),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x1e68(%rsp,%r12,2),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  %xmm11,%xmm0
divsd  0x10(%rsp),%xmm0
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
mov    %rsi,(%rsp)
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1e96(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
mulsd  0x8(%rsp),%xmm0
mulsd  0x8(%rbx,%r12,2),%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r12,2)
movsd  0x8(%rbx,%r12,2),%xmm10
mov    0x43f8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm10,%xmm2
movsd  0x1e84(%rip),%xmm1
mulsd  %xmm1,%xmm2
mulsd  (%rax,%r13,8),%xmm10
mov    (%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm1,%xmm10
mulsd  %xmm1,%xmm0
jmp    277a <linearize+0x164a>
mov    0x38(%rsp),%rbx
movsd  0x8(%rbx,%r12,2),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x1e68(%rsp,%r12,2),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  %xmm11,%xmm0
divsd  0x10(%rsp),%xmm0
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
mov    %rsi,(%rsp)
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1daf(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
mulsd  0x8(%rsp),%xmm0
mulsd  0x8(%rbx,%r12,2),%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r12,2)
mov    0x43f8(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
mulsd  0x8(%rbx,%r12,2),%xmm2
movsd  0x1da1(%rip),%xmm1
mulsd  %xmm1,%xmm2
mov    (%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm9
mulsd  %xmm0,%xmm9
mov    0x50(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm1,%xmm9
mulsd  %xmm1,%xmm0
jmp    28b6 <linearize+0x1786>
movsd  0x1e68(%rsp,%r12,2),%xmm0
mulsd  0x1d7c(%rip),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x1d71(%rip),%xmm1
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x1d3f(%rip),%xmm1
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  0x1cce(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1c9b(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
mulsd  (%rsp),%xmm0
mov    0x38(%rsp),%rcx
mulsd  0x8(%rcx,%r12,2),%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r12,2)
movsd  0x8(%rcx,%r12,2),%xmm0
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x8(%rcx,%r12,2)
mov    0x43f8(%rsp),%rcx
movsd  (%rcx,%r13,8),%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
divsd  0x1c84(%rip),%xmm2
movsd  0x8(%rax,%r12,2),%xmm0
xorpd  %xmm8,%xmm8
xorpd  %xmm9,%xmm9
xorpd  %xmm10,%xmm10
jmp    2a30 <linearize+0x1900>
movsd  0x1e68(%rsp,%r12,2),%xmm0
mulsd  0x1c5f(%rip),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x1c54(%rip),%xmm1
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x1c22(%rip),%xmm1
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  0x1bb1(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1b7e(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
mulsd  (%rsp),%xmm0
mov    0x38(%rsp),%rcx
mulsd  0x8(%rcx,%r12,2),%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r12,2)
movsd  0x8(%rcx,%r12,2),%xmm0
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x8(%rcx,%r12,2)
mov    0x43f8(%rsp),%rcx
movsd  (%rcx,%r13,8),%xmm10
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm10,%xmm2
mulsd  %xmm0,%xmm2
divsd  0x1b59(%rip),%xmm2
mulsd  %xmm10,%xmm10
mulsd  %xmm0,%xmm10
divsd  0x1b4e(%rip),%xmm10
movsd  0x8(%rax,%r12,2),%xmm0
jmp    277a <linearize+0x164a>
mov    0x38(%rsp),%rbx
movsd  0x8(%rbx,%r12,2),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x1e68(%rsp,%r12,2),%xmm0
mulsd  0x1af7(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x1aeb(%rip),%xmm1
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
mov    %rsi,(%rsp)
call   1050 <pow@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  0x1a81(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1a4e(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
movapd %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0x8(%rbx,%r12,2),%xmm1
mov    0x40(%rsp),%rax
movsd  %xmm1,0x8(%rax,%r12,2)
movsd  0x8(%rbx,%r12,2),%xmm10
mov    0x43f8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm10,%xmm2
movsd  0x1a38(%rip),%xmm0
mulsd  %xmm0,%xmm2
mulsd  (%rax,%r13,8),%xmm10
mulsd  %xmm0,%xmm10
mov    (%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movapd %xmm0,%xmm9
mulsd  %xmm0,%xmm9
mulsd  %xmm1,%xmm9
mov    0x50(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  0x1a0e(%rip),%xmm9
mulsd  %xmm1,%xmm0
divsd  0x19fa(%rip),%xmm0
xorpd  %xmm8,%xmm8
jmp    2a30 <linearize+0x1900>
mov    0x38(%rsp),%rbx
movsd  0x8(%rbx,%r12,2),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x1e68(%rsp,%r12,2),%xmm0
mulsd  0x19ad(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x19a1(%rip),%xmm1
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
mov    %rsi,(%rsp)
call   1050 <pow@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  0x1937(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1904(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
movapd %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0x8(%rbx,%r12,2),%xmm1
mov    0x40(%rsp),%rax
movsd  %xmm1,0x8(%rax,%r12,2)
movsd  0x8(%rbx,%r12,2),%xmm10
mov    0x43f8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm10,%xmm2
mulsd  (%rax,%r13,8),%xmm10
movsd  0x18e8(%rip),%xmm0
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm10
mov    (%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
divsd  0x18d6(%rip),%xmm0
xorpd  %xmm8,%xmm8
xorpd  %xmm9,%xmm9
jmp    2a30 <linearize+0x1900>
mov    0x38(%rsp),%rbx
movsd  0x8(%rbx,%r12,2),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x1e68(%rsp,%r12,2),%xmm0
mulsd  0x187c(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x1870(%rip),%xmm1
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
mov    %rsi,(%rsp)
call   1050 <pow@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  0x1806(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x17d3(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
movapd %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0x8(%rbx,%r12,2),%xmm1
mov    0x40(%rsp),%rax
movsd  %xmm1,0x8(%rax,%r12,2)
mov    0x43f8(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
mulsd  0x8(%rbx,%r12,2),%xmm2
mulsd  0x17c1(%rip),%xmm2
mov    0x50(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    (%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm9
mulsd  %xmm0,%xmm9
mulsd  %xmm1,%xmm9
divsd  0x17a2(%rip),%xmm9
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
divsd  0x179a(%rip),%xmm0
xorpd  %xmm8,%xmm8
xorpd  %xmm10,%xmm10
jmp    2a30 <linearize+0x1900>
mov    0x38(%rsp),%rbx
movsd  0x8(%rbx,%r12,2),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x1e68(%rsp,%r12,2),%xmm0
mulsd  0x1740(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x1734(%rip),%xmm1
movsd  %xmm13,0x28(%rsp)
movsd  %xmm14,0x20(%rsp)
movsd  %xmm15,0x18(%rsp)
mov    %rsi,(%rsp)
call   1050 <pow@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b38(%rsp,%r12,2),%xmm0
xorpd  0x16ca(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
mov    0x48(%rsp),%rdx
movsd  0x18(%rsp),%xmm15
movsd  0x20(%rsp),%xmm14
movsd  0x28(%rsp),%xmm13
xorpd  %xmm12,%xmm12
movapd 0x1697(%rip),%xmm11
mov    0x43f0(%rsp),%rbp
movapd %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0x8(%rbx,%r12,2),%xmm1
mov    0x40(%rsp),%rax
movsd  %xmm1,0x8(%rax,%r12,2)
movsd  0x8(%rbx,%r12,2),%xmm10
mov    0x43f8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm10,%xmm2
movsd  0x1681(%rip),%xmm0
mulsd  %xmm0,%xmm2
mulsd  (%rax,%r13,8),%xmm10
mulsd  %xmm0,%xmm10
mov    0x50(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    (%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm9
movapd %xmm0,%xmm8
mulsd  %xmm9,%xmm8
mulsd  %xmm1,%xmm8
movsd  0x164f(%rip),%xmm3
divsd  %xmm3,%xmm8
mov    0x58(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm9
mulsd  %xmm1,%xmm9
divsd  %xmm3,%xmm9
mulsd  %xmm4,%xmm0
mulsd  %xmm1,%xmm0
divsd  %xmm3,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1689(%rip),%rax
movsd  (%rax,%r15,8),%xmm6
lea    0x16dc(%rip),%rax
movsd  (%rax,%r15,8),%xmm4
mov    $0x1b,%edi
sub    %r13d,%edi
mov    $0x1b,%ebx
sub    %rdx,%rbx
imul   $0xd8,%rdi,%rax
lea    (%rsp,%rax,1),%r9
add    $0x380,%r9
movapd %xmm6,%xmm1
mulsd  %xmm2,%xmm1
addsd  (%r9,%rdi,8),%xmm1
movsd  %xmm1,(%r9,%rdi,8)
test   %edx,%edx
jle    2aa6 <linearize+0x1976>
imul   $0xd8,%rbx,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm4,%xmm1
mulsd  %xmm2,%xmm1
addsd  (%rax,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
mov    $0x1b,%r8d
mov    0x68(%rsp),%rax
sub    %rax,%r8
test   %eax,%eax
mov    0x50(%rsp),%r13
jle    2ae0 <linearize+0x19b0>
imul   $0xd8,%r8,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm15,%xmm1
mulsd  %xmm2,%xmm1
addsd  (%rax,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
mov    $0x1b,%eax
mov    0x58(%rsp),%rcx
sub    %rcx,%rax
test   %ecx,%ecx
jle    2b19 <linearize+0x19e9>
imul   $0xd8,%rax,%rcx
add    %rsp,%rcx
add    $0x380,%rcx
movsd  (%rcx,%rdi,8),%xmm1
movapd %xmm14,%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
mov    $0x1b,%ecx
sub    %r13,%rcx
mov    $0x1b,%edx
sub    %r14d,%edx
test   %r13d,%r13d
jle    2b56 <linearize+0x1a26>
imul   $0xd8,%rcx,%rsi
add    %rsp,%rsi
add    $0x380,%rsi
movsd  (%rsi,%rdi,8),%xmm1
movapd %xmm13,%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
lea    0x1623(%rip),%rsi
movsd  (%rsi,%r15,8),%xmm3
mov    %edx,%edx
imul   $0xd8,%rdx,%rsi
lea    (%rsp,%rsi,1),%r10
add    $0x380,%r10
movsd  (%r10,%rdi,8),%xmm1
movapd %xmm3,%xmm7
xorpd  %xmm11,%xmm7
movapd %xmm3,%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%r10,%rdi,8)
movslq %ecx,%r11
movslq %eax,%rdi
movslq %ebx,%rbx
mov    0x48(%rsp),%rsi
test   %esi,%esi
jle    2cb9 <linearize+0x1b89>
movapd %xmm6,%xmm1
mulsd  %xmm10,%xmm1
addsd  (%r9,%rbx,8),%xmm1
imul   $0xd8,%rbx,%rax
movsd  %xmm1,(%r9,%rbx,8)
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm4,%xmm1
mulsd  %xmm10,%xmm1
addsd  (%rax,%rbx,8),%xmm1
movsd  %xmm1,(%rax,%rbx,8)
mov    0x68(%rsp),%r15
test   %r15d,%r15d
jle    2c18 <linearize+0x1ae8>
movslq %r8d,%rcx
imul   $0xd8,%rcx,%rcx
add    %rsp,%rcx
add    $0x380,%rcx
movapd %xmm15,%xmm1
mulsd  %xmm10,%xmm1
addsd  (%rcx,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
mov    0x58(%rsp),%r14
test   %r14d,%r14d
jle    2c4b <linearize+0x1b1b>
imul   $0xd8,%rdi,%rcx
add    %rsp,%rcx
add    $0x380,%rcx
movsd  (%rcx,%rbx,8),%xmm1
movapd %xmm14,%xmm5
mulsd  %xmm10,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
test   %r13d,%r13d
jle    2c79 <linearize+0x1b49>
imul   $0xd8,%r11,%rcx
add    %rsp,%rcx
add    $0x380,%rcx
movsd  (%rcx,%rbx,8),%xmm1
movapd %xmm13,%xmm5
mulsd  %xmm10,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
movapd %xmm7,%xmm1
mulsd  %xmm10,%xmm1
addsd  (%r10,%rbx,8),%xmm1
movsd  %xmm1,(%r10,%rbx,8)
test   %r15d,%r15d
jle    2d77 <linearize+0x1c47>
movslq %r8d,%rcx
movapd %xmm6,%xmm1
mulsd  %xmm12,%xmm1
addsd  (%r9,%rcx,8),%xmm1
movsd  %xmm1,(%r9,%rcx,8)
lea    (%rax,%rcx,8),%rax
movapd %xmm4,%xmm1
jmp    2cd7 <linearize+0x1ba7>
mov    0x68(%rsp),%r15
test   %r15d,%r15d
mov    0x58(%rsp),%r14
jle    2d77 <linearize+0x1c47>
movslq %r8d,%rcx
lea    (%r9,%rcx,8),%rax
movapd %xmm6,%xmm1
mulsd  %xmm12,%xmm1
addsd  (%rax),%xmm1
imul   $0xd8,%rcx,%rsi
movsd  %xmm1,(%rax)
lea    (%rsp,%rsi,1),%rax
add    $0x380,%rax
movapd %xmm15,%xmm1
mulsd  %xmm12,%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
test   %r14d,%r14d
jle    2d35 <linearize+0x1c05>
imul   $0xd8,%rdi,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm14,%xmm1
mulsd  0x1345(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
test   %r13d,%r13d
mov    0x48(%rsp),%rsi
jle    2d66 <linearize+0x1c36>
imul   $0xd8,%r11,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm13,%xmm1
mulsd  0x1314(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
mulsd  %xmm12,%xmm7
addsd  (%r10,%rcx,8),%xmm7
movsd  %xmm7,(%r10,%rcx,8)
test   %r14d,%r14d
jle    2e56 <linearize+0x1d26>
movsd  (%r9,%rdi,8),%xmm1
movapd %xmm6,%xmm5
mulsd  %xmm8,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%r9,%rdi,8)
test   %esi,%esi
jle    2dc4 <linearize+0x1c94>
imul   $0xd8,%rbx,%rax
add    %rsp,%rax
add    $0x380,%rax
movsd  (%rax,%rdi,8),%xmm1
movapd %xmm4,%xmm5
mulsd  %xmm8,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
test   %r15d,%r15d
jle    2df4 <linearize+0x1cc4>
movslq %r8d,%rax
imul   $0xd8,%rax,%rax
add    %rsp,%rax
add    $0x380,%rax
movsd  (%rax,%rdi,8),%xmm1
movapd %xmm15,%xmm5
mulsd  %xmm8,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
imul   $0xd8,%rdi,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm14,%xmm1
mulsd  %xmm8,%xmm1
addsd  (%rax,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
test   %r13d,%r13d
jle    2e41 <linearize+0x1d11>
imul   $0xd8,%r11,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm13,%xmm1
mulsd  %xmm8,%xmm1
addsd  (%rax,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
movapd %xmm3,%xmm1
mulsd  %xmm8,%xmm1
addsd  (%r10,%rdi,8),%xmm1
movsd  %xmm1,(%r10,%rdi,8)
test   %r13d,%r13d
jle    2f44 <linearize+0x1e14>
movsd  (%r9,%r11,8),%xmm1
movapd %xmm6,%xmm5
mulsd  %xmm9,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%r9,%r11,8)
test   %esi,%esi
jle    2ea5 <linearize+0x1d75>
imul   $0xd8,%rbx,%rax
add    %rsp,%rax
add    $0x380,%rax
movsd  (%rax,%r11,8),%xmm1
movapd %xmm4,%xmm5
mulsd  %xmm9,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rax,%r11,8)
test   %r15d,%r15d
jle    2ed7 <linearize+0x1da7>
movslq %r8d,%rax
imul   $0xd8,%rax,%rax
add    %rsp,%rax
add    $0x380,%rax
movsd  (%rax,%r11,8),%xmm1
movapd %xmm15,%xmm5
mulsd  %xmm9,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rax,%r11,8)
test   %r14d,%r14d
jle    2f02 <linearize+0x1dd2>
imul   $0xd8,%rdi,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm14,%xmm1
mulsd  %xmm9,%xmm1
addsd  (%rax,%r11,8),%xmm1
movsd  %xmm1,(%rax,%r11,8)
xorpd  %xmm11,%xmm6
imul   $0xd8,%r11,%rax
add    %rsp,%rax
add    $0x380,%rax
movapd %xmm13,%xmm1
mulsd  %xmm9,%xmm1
addsd  (%rax,%r11,8),%xmm1
movsd  %xmm1,(%rax,%r11,8)
movapd %xmm3,%xmm1
mulsd  %xmm9,%xmm1
addsd  (%r10,%r11,8),%xmm1
movsd  %xmm1,(%r10,%r11,8)
jmp    2f49 <linearize+0x1e19>
xorpd  %xmm11,%xmm6
mulsd  %xmm0,%xmm6
addsd  (%r9,%rdx,8),%xmm6
movsd  %xmm6,(%r9,%rdx,8)
test   %esi,%esi
jle    2f7f <linearize+0x1e4f>
imul   $0xd8,%rbx,%rax
add    %rsp,%rax
add    $0x380,%rax
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm4
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
test   %r15d,%r15d
jle    2fab <linearize+0x1e7b>
movslq %r8d,%rax
imul   $0xd8,%rax,%rax
add    %rsp,%rax
add    $0x380,%rax
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm15
subsd  %xmm15,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
test   %r14d,%r14d
jle    2fd1 <linearize+0x1ea1>
imul   $0xd8,%rdi,%rax
add    %rsp,%rax
add    $0x380,%rax
mulsd  %xmm0,%xmm14
addsd  (%rax,%rdx,8),%xmm14
movsd  %xmm14,(%rax,%rdx,8)
test   %r13d,%r13d
jle    1e00 <linearize+0xcd0>
imul   $0xd8,%r11,%rax
add    %rsp,%rax
add    $0x380,%rax
mulsd  %xmm0,%xmm13
addsd  (%rax,%rdx,8),%xmm13
movsd  %xmm13,(%rax,%rdx,8)
jmp    1e00 <linearize+0xcd0>
movapd 0x80(%rsp),%xmm5
mulsd  0x1037(%rip),%xmm5
mulsd  0x105f(%rip),%xmm5
unpcklpd %xmm5,%xmm5
movapd 0x90(%rsp),%xmm6
unpcklpd %xmm6,%xmm6
lea    0x460(%rsp),%rax
mov    $0x1,%ecx
movsd  0x1041(%rip),%xmm0
nop
mov    $0x1b,%edx
sub    %rcx,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm1
unpcklpd %xmm1,%xmm1
mov    $0x19,%esi
mov    %rax,%rdi
nopw   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm2
movhpd 0xd8(%rdi),%xmm2
movapd %xmm2,%xmm3
andpd  0xfa8(%rip),%xmm3
movupd 0x0(%rbp,%rsi,8),%xmm4
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm5,%xmm4
divpd  %xmm1,%xmm4
cmpnltpd %xmm4,%xmm3
mulpd  %xmm6,%xmm2
andpd  %xmm3,%xmm2
movlpd %xmm2,(%rdi)
pshufd $0xee,%xmm2,%xmm2
movq   %xmm2,0xd8(%rdi)
add    $0x1b0,%rdi
add    $0xfffffffffffffffe,%rsi
cmp    $0xffffffffffffffff,%rsi
jne    3060 <linearize+0x1f30>
imul   $0xd8,%rcx,%rsi
add    %rsp,%rsi
add    $0x380,%rsi
movsd  (%rsi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x1a50(%rsp,%rdx,8)
add    $0x1,%rcx
add    $0x8,%rax
cmp    $0x1b,%rcx
jne    3040 <linearize+0x1f10>
movapd %xmm6,0x80(%rsp)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x158(%rsp)
movupd %xmm0,0x148(%rsp)
movupd %xmm0,0x138(%rsp)
movupd %xmm0,0x128(%rsp)
movupd %xmm0,0x118(%rsp)
movupd %xmm0,0x108(%rsp)
movupd %xmm0,0xf8(%rsp)
movupd %xmm0,0xe8(%rsp)
movupd %xmm0,0xd8(%rsp)
movupd %xmm0,0xc8(%rsp)
movupd %xmm0,0xb8(%rsp)
movupd %xmm0,0xa8(%rsp)
movq   $0x0,0x168(%rsp)
lea    0x1e8(%rsp),%rdi
lea    0x1a58(%rsp),%rsi
mov    $0xd0,%edx
call   1030 <memcpy@plt>
xor    %eax,%eax
cmpl   $0x1,0x78(%rsp)
cmove  0x7c(%rsp),%eax
mov    %eax,0x8(%rsp)
cmp    0x74(%rsp),%eax
jne    321e <linearize+0x20ee>
mov    $0x1,%eax
lea    0x380(%rsp),%rcx
lea    0x2cf0(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x1b8,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0xd8(%rcx,%rsi,1),%xmm0
ff ff
movsd  %xmm0,-0xd8(%rdx,%rsi,1)
ff ff
movsd  (%rcx,%rsi,1),%xmm0
movsd  %xmm0,(%rdx,%rsi,1)
add    $0x1b0,%rsi
cmp    $0x17a8,%rsi
jne    31e0 <linearize+0x20b0>
add    $0x1,%rax
add    $0x8,%rcx
add    $0x8,%rdx
cmp    $0x1b,%rax
jne    31d0 <linearize+0x20a0>
lea    0x478(%rsp),%rdx
lea    0x550(%rsp),%rax
mov    %rax,0x30(%rsp)
lea    0x460(%rsp),%rdi
lea    0x538(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    $0x2,%r8d
mov    $0x1,%ecx
mov    $0x19,%eax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x60(%rsp)
xorpd  %xmm0,%xmm0
movapd 0xd9f(%rip),%xmm8
jmp    32be <linearize+0x218e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8
addq   $0x1,0x60(%rsp)
addq   $0xffffffffffffffff,0x38(%rsp)
add    $0xe0,%rdx
addq   $0xe0,0x30(%rsp)
add    $0xd8,%rdi
addq   $0xd8,0x40(%rsp)
mov    (%rsp),%rcx
cmp    $0x1b,%rcx
je     353e <linearize+0x240e>
mov    %rcx,%rax
imul   $0xd8,%rcx,%rcx
add    %rsp,%rcx
add    $0x380,%rcx
mov    %rcx,0x58(%rsp)
movsd  (%rcx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    32e8 <linearize+0x21b8>
jnp    3939 <linearize+0x2809>
lea    0x1(%rax),%rcx
mov    %rcx,(%rsp)
cmp    $0x19,%rax
ja     3280 <linearize+0x2150>
mov    0x38(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    $0x19,%r10d
mov    0x60(%rsp),%rbx
sub    %rbx,%r10
lea    (%rbx,%rbx,8),%rbp
lea    0x0(,%rbp,2),%rsi
add    %rbp,%rsi
add    %rbx,%rsi
or     $0x2,%rsi
lea    0x3(%rbx),%rbp
mov    %rbp,0x28(%rsp)
mov    %rsi,0x68(%rsp)
lea    (%rsp,%rsi,8),%rsi
add    $0x458,%rsi
mov    %rsi,0x20(%rsp)
imul   $0xd8,%r8,%rbp
lea    (%rsp,%rbp,1),%rsi
add    $0x380,%rsi
mov    %rsi,0x50(%rsp)
mov    0x58(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    %rsi,0x48(%rsp)
mov    %r10,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x18(%rsp)
add    %r8,%rsi
mov    %rsi,0x10(%rsp)
mov    0x40(%rsp),%r15
mov    0x30(%rsp),%r9
xor    %r11d,%r11d
mov    %r8,%rbx
jmp    33d4 <linearize+0x22a4>
nopl   0x0(%rax)
lea    (%r14,%rax,8),%rbp
mulsd  0x1e0(%rsp,%rax,8),%xmm2
movsd  %xmm1,0x0(%rbp)
addsd  0x1e0(%rsp,%rbx,8),%xmm2
movsd  %xmm2,0x1e0(%rsp,%rbx,8)
add    $0x1,%rbx
add    $0x1,%r11
add    $0xd8,%r9
add    $0xd8,%r15
cmp    $0x1b,%rbx
je     3280 <linearize+0x2150>
imul   $0xd8,%rbx,%rbp
lea    (%rsp,%rbp,1),%r14
add    $0x380,%r14
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    33f4 <linearize+0x22c4>
jnp    33b4 <linearize+0x2284>
mov    0x48(%rsp),%rsi
divsd  (%rsi),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm8,%xmm2
mov    %r8,%r12
cmp    $0x4,%r10
jb     34c0 <linearize+0x2390>
imul   $0xd8,%r11,%rbp
lea    0x380(%rsp),%rsi
add    %rsi,%rbp
mov    0x68(%rsp),%rsi
lea    0x1b0(%rbp,%rsi,8),%rbp
cmp    0x50(%rsp),%rbp
jae    345d <linearize+0x232d>
mov    0x28(%rsp),%rsi
lea    (%rsi,%r11,1),%rbp
imul   $0xd8,%rbp,%rbp
add    %rsp,%rbp
add    $0x380,%rbp
mov    %r8,%r12
cmp    %rbp,0x20(%rsp)
jb     34c0 <linearize+0x2390>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rbp,8),%xmm4
movupd (%rdx,%rbp,8),%xmm5
movupd -0x10(%r9,%rbp,8),%xmm6
movupd (%r9,%rbp,8),%xmm7
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm7,%xmm5
movupd %xmm4,-0x10(%r9,%rbp,8)
movupd %xmm5,(%r9,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    3470 <linearize+0x2340>
mov    0x10(%rsp),%r12
cmp    0x18(%rsp),%r10
je     3390 <linearize+0x2260>
xchg   %ax,%ax
mov    $0x1,%ebp
sub    %r12d,%ebp
mov    %r12,%r13
test   $0x1,%bpl
je     34f1 <linearize+0x23c1>
mov    0x58(%rsp),%rsi
movsd  (%rsi,%r12,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r14,%r12,8),%xmm3
movsd  %xmm3,(%r14,%r12,8)
lea    0x1(%r12),%r13
cmp    $0x1a,%r12
je     3390 <linearize+0x2260>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%r13,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  -0x8(%r15,%r13,8),%xmm3
movsd  %xmm3,-0x8(%r15,%r13,8)
movsd  (%rdi,%r13,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r15,%r13,8),%xmm3
movsd  %xmm3,(%r15,%r13,8)
add    $0x2,%r13
cmp    $0x1b,%r13
jne    3500 <linearize+0x23d0>
jmp    3390 <linearize+0x2260>
movsd  0x1a40(%rsp),%xmm8
lea    0x2b0(%rsp),%r10
lea    0x1968(%rsp),%r11
lea    0x18a0(%rsp),%r14
lea    0x2dd0(%rsp),%r8
mov    $0x1,%r15b
xorpd  %xmm1,%xmm1
lea    0x618(%rsp),%r9
movsd  0xb09(%rip),%xmm2
xorpd  %xmm3,%xmm3
movapd 0x80(%rsp),%xmm7
movapd 0xa8c(%rip),%xmm0
movsd  0x2b0(%rsp),%xmm4
divsd  %xmm8,%xmm4
movsd  %xmm4,0x2b0(%rsp)
addsd  %xmm3,%xmm4
movsd  %xmm4,0x170(%rsp)
mov    $0x19,%ebx
mov    $0xffffffffffffffe7,%r12
mov    %r14,%rsi
mov    $0x1,%bpl
mov    %r11,%rdx
mov    %r10,%rax
xor    %r13d,%r13d
jmp    364d <linearize+0x251d>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x1e0(%rsp,%rbx,8),%xmm4
subsd  %xmm3,%xmm4
imul   $0xd8,%rbx,%rcx
add    %rsp,%rcx
add    $0x380,%rcx
divsd  (%rcx,%rbx,8),%xmm4
movsd  %xmm4,0x1e0(%rsp,%rbx,8)
addsd  0xa0(%rsp,%rbx,8),%xmm4
movsd  %xmm4,0xa0(%rsp,%rbx,8)
lea    -0x1(%rbx),%rcx
add    $0x1,%r13
add    $0x1,%r12
add    $0xfffffffffffffff8,%rax
add    $0xffffffffffffff20,%rdx
add    $0x1,%bpl
add    $0xffffffffffffff28,%rsi
cmp    $0x1,%rbx
mov    %rcx,%rbx
jbe    3710 <linearize+0x25e0>
movzbl %bpl,%ebp
and    $0x3,%ebp
lea    0x1(%r13),%edi
xorpd  %xmm3,%xmm3
test   $0x3,%dil
je     36a0 <linearize+0x2570>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rdi,8),%xmm4
mulsd  (%rax,%rdi,8),%xmm4
addsd  %xmm4,%xmm3
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    3670 <linearize+0x2540>
sub    %r12,%rdi
cmp    $0x3,%r13
jae    36b0 <linearize+0x2580>
jmp    35e0 <linearize+0x24b0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
cmp    $0x3,%r13
jb     35e0 <linearize+0x24b0>
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm4
movsd  0x8(%rsi,%rdi,8),%xmm5
mulsd  0x1e8(%rsp,%rdi,8),%xmm4
mulsd  0x1f0(%rsp,%rdi,8),%xmm5
addsd  %xmm3,%xmm4
movsd  0x10(%rsi,%rdi,8),%xmm6
mulsd  0x1f8(%rsp,%rdi,8),%xmm6
addsd  %xmm4,%xmm5
movsd  0x18(%rsi,%rdi,8),%xmm3
mulsd  0x200(%rsp,%rdi,8),%xmm3
addsd  %xmm5,%xmm6
lea    0x4(%rdi),%rcx
addsd  %xmm6,%xmm3
mov    %rcx,%rdi
cmp    $0x1a,%rcx
jne    36b0 <linearize+0x2580>
jmp    35e0 <linearize+0x24b0>
nopl   (%rax)
mov    0x8(%rsp),%eax
cmp    0x74(%rsp),%eax
mov    0x4400(%rsp),%r12
jne    38b5 <linearize+0x2785>
mov    $0x2,%ecx
xor    %eax,%eax
jmp    3740 <linearize+0x2610>
nop
add    $0x2,%rcx
mov    $0x1,%al
cmp    $0x1c,%rcx
je     38b5 <linearize+0x2785>
movsd  0x98(%rsp,%rcx,8),%xmm3
ucomisd %xmm1,%xmm3
jne    3751 <linearize+0x2621>
jnp    3768 <linearize+0x2638>
movsd  0x1d8(%rsp,%rcx,8),%xmm4
divsd  %xmm3,%xmm4
andpd  %xmm0,%xmm4
ucomisd %xmm2,%xmm4
ja     3792 <linearize+0x2662>
movsd  0xa0(%rsp,%rcx,8),%xmm3
ucomisd %xmm1,%xmm3
jne    3779 <linearize+0x2649>
jnp    3730 <linearize+0x2600>
movsd  0x1e0(%rsp,%rcx,8),%xmm4
divsd  %xmm3,%xmm4
andpd  %xmm0,%xmm4
ucomisd %xmm2,%xmm4
jbe    3730 <linearize+0x2600>
mov    $0x1,%al
test   $0x1,%r15b
je     39ab <linearize+0x287b>
mov    $0x1,%ecx
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm3,%xmm3
mov    $0x1,%esi
nopl   0x0(%rax)
movsd  -0x8(%rdx,%rsi,8),%xmm4
movsd  (%rdx,%rsi,8),%xmm5
mulsd  0xa0(%rsp,%rsi,8),%xmm4
mulsd  0xa8(%rsp,%rsi,8),%xmm5
addsd  %xmm3,%xmm4
movapd %xmm5,%xmm3
addsd  %xmm4,%xmm3
add    $0x2,%rsi
cmp    $0x1b,%rsi
jne    37c0 <linearize+0x2690>
movsd  0x1a50(%rsp,%rcx,8),%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,0x1e0(%rsp,%rcx,8)
add    $0x1,%rcx
add    $0xd8,%rdx
cmp    $0x1b,%rcx
jne    37b0 <linearize+0x2680>
mov    $0x3,%ebp
mov    $0x2,%esi
mov    %r9,%rdx
jmp    3841 <linearize+0x2711>
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0xe0,%rdx
cmp    $0x1b,%rsi
je     38a0 <linearize+0x2770>
mov    %rsi,%rdi
add    $0x1,%rsi
cmp    $0x19,%rdi
ja     3830 <linearize+0x2700>
mov    %rdx,%rbx
mov    %rbp,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx),%xmm3
movsd  0x1e0(%rsp,%rcx,8),%xmm4
mulsd  0x1e0(%rsp,%rdi,8),%xmm3
subsd  %xmm3,%xmm4
movsd  %xmm4,0x1e0(%rsp,%rcx,8)
add    $0x1,%rcx
add    $0xd8,%rbx
cmp    $0x1b,%rcx
jne    3860 <linearize+0x2730>
jmp    3830 <linearize+0x2700>
cs nopw 0x0(%rax,%rax,1)
test   $0x1,%al
jne    38b5 <linearize+0x2785>
movsd  0x170(%rsp),%xmm3
xor    %r15d,%r15d
jmp    3594 <linearize+0x2464>
lea    0x8(%r12),%rax
mov    0x43f0(%rsp),%rdx
lea    0xd8(%rdx),%rcx
cmp    %rcx,%rax
jae    394b <linearize+0x281b>
lea    0xd8(%r12),%rax
lea    0x8(%rdx),%rcx
cmp    %rax,%rcx
jae    394b <linearize+0x281b>
lea    0x170(%rsp),%rax
mov    $0x2,%ecx
movapd 0x90(%rsp),%xmm1
nopl   0x0(%rax)
movsd  (%rax),%xmm0
subsd  -0x8(%rdx,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%r12,%rcx,8)
movsd  -0x8(%rax),%xmm0
subsd  (%rdx,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x2,%rcx
add    $0xfffffffffffffff0,%rax
cmp    $0x1c,%rcx
jne    3900 <linearize+0x27d0>
xor    %eax,%eax
add    $0x43b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x168(%rsp),%rax
mov    $0x3,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%rax),%xmm0
shufpd $0x1,%xmm0,%xmm0
movupd -0x10(%rdx,%rcx,8),%xmm1
subpd  %xmm1,%xmm0
divpd  %xmm7,%xmm0
movupd %xmm0,-0x10(%r12,%rcx,8)
cmp    $0x1b,%rcx
je     3937 <linearize+0x2807>
movupd -0x10(%rax),%xmm0
shufpd $0x1,%xmm0,%xmm0
movupd (%rdx,%rcx,8),%xmm1
subpd  %xmm1,%xmm0
divpd  %xmm7,%xmm0
movupd %xmm0,(%r12,%rcx,8)
add    $0x4,%rcx
add    $0xffffffffffffffe0,%rax
jmp    3960 <linearize+0x2830>
mov    $0xffffffff,%eax
jmp    3939 <linearize+0x2809>

LLVM IR (-O0):
@__const.linearize.nn1 = [12 x double] [double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 2.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 1.000000e+00]
@__const.linearize.nn2 = [12 x double] [double 0.000000e+00, double 1.000000e+00, double 1.000000e+00, double 0.000000e+00, double 1.000000e+00, double 0.000000e+00, double 0.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 0.000000e+00, double 1.000000e+00]
@__const.linearize.nn6 = [12 x double] [double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 2.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 1.000000e+00, double 1.000000e+00]
define i32 @linearize(double %0, [10 x double]* %1, double* %2, double* %3, i32 %4, i32 %5, i32 %6, double %7, double* %8, double* %9, double* %10, double %11, double %12) {
%14 = alloca i32
%15 = alloca double
%16 = alloca [10 x double]*
%17 = alloca double*
%18 = alloca double*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca double
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double
%27 = alloca double
%28 = alloca [12 x double]
%29 = alloca [12 x double]
%30 = alloca [12 x double]
%31 = alloca [12 x double]
%32 = alloca [12 x double]
%33 = alloca [12 x double]
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca [27 x double]
%57 = alloca i32
%58 = alloca double
%59 = alloca i32
%60 = alloca [101 x i32]
%61 = alloca [101 x i32]
%62 = alloca [101 x i32]
%63 = alloca [101 x i32]
%64 = alloca [101 x i32]
%65 = alloca [101 x i32]
%66 = alloca [101 x i32]
%67 = alloca [101 x double]
%68 = alloca [101 x double]
%69 = alloca [27 x [27 x double]]
%70 = alloca [27 x double]
%71 = alloca [27 x double]
%72 = alloca i32
%73 = alloca [27 x double]
%74 = alloca [27 x [27 x double]]
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double
%79 = alloca i32
%80 = alloca i32
store double %0, double* %15
store [10 x double]* %1, [10 x double]** %16
store double* %2, double** %17
store double* %3, double** %18
store i32 %4, i32* %19
store i32 %5, i32* %20
store i32 %6, i32* %21
store double %7, double* %22
store double* %8, double** %23
store double* %9, double** %24
store double* %10, double** %25
store double %11, double* %26
store double %12, double* %27
%81 = bitcast [12 x double]* %28 to i8*
%82 = bitcast [12 x double]* %29 to i8*
%83 = bitcast [12 x double]* %30 to i8*
%84 = bitcast [12 x double]* %31 to i8*
%85 = bitcast i8* %84 to [12 x double]*
%86 = getelementptr inbounds [12 x double], [12 x double]* %85, i32 0, i32 11
store double 1.000000e+00, double* %86
%87 = bitcast [12 x double]* %32 to i8*
%88 = bitcast i8* %87 to [12 x double]*
%89 = getelementptr inbounds [12 x double], [12 x double]* %88, i32 0, i32 2
store double 1.000000e+00, double* %89
%90 = getelementptr inbounds [12 x double], [12 x double]* %88, i32 0, i32 5
store double 1.000000e+00, double* %90
%91 = getelementptr inbounds [12 x double], [12 x double]* %88, i32 0, i32 8
store double 1.000000e+00, double* %91
%92 = getelementptr inbounds [12 x double], [12 x double]* %88, i32 0, i32 10
store double 2.000000e+00, double* %92
%93 = getelementptr inbounds [12 x double], [12 x double]* %88, i32 0, i32 11
store double 1.000000e+00, double* %93
%94 = bitcast [12 x double]* %33 to i8*
store double 0.000000e+00, double* %49
store double 0.000000e+00, double* %48
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %45
store double 0.000000e+00, double* %44
store i32 0, i32* %59
store i32 1, i32* %34
br label %95
95: ; preds = %187, %13
%96 = load i32, i32* %34
%97 = icmp sle i32 %96, 100
br i1 %97, label %98, label %190
98: ; preds = %95
%99 = load [10 x double]*, [10 x double]** %16
%100 = load i32, i32* %34
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [10 x double], [10 x double]* %99, i64 %101
%103 = getelementptr inbounds [10 x double], [10 x double]* %102, i64 0, i64 1
%104 = load double, double* %103
%105 = fptosi double %104 to i32
%106 = load i32, i32* %34
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [101 x i32], [101 x i32]* %60, i64 0, i64 %107
store i32 %105, i32* %108
%109 = load [10 x double]*, [10 x double]** %16
%110 = load i32, i32* %34
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [10 x double], [10 x double]* %109, i64 %111
%113 = getelementptr inbounds [10 x double], [10 x double]* %112, i64 0, i64 2
%114 = load double, double* %113
%115 = fptosi double %114 to i32
%116 = load i32, i32* %34
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [101 x i32], [101 x i32]* %61, i64 0, i64 %117
store i32 %115, i32* %118
%119 = load [10 x double]*, [10 x double]** %16
%120 = load i32, i32* %34
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [10 x double], [10 x double]* %119, i64 %121
%123 = getelementptr inbounds [10 x double], [10 x double]* %122, i64 0, i64 3
%124 = load double, double* %123
%125 = fptosi double %124 to i32
%126 = load i32, i32* %34
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [101 x i32], [101 x i32]* %62, i64 0, i64 %127
store i32 %125, i32* %128
%129 = load [10 x double]*, [10 x double]** %16
%130 = load i32, i32* %34
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [10 x double], [10 x double]* %129, i64 %131
%133 = getelementptr inbounds [10 x double], [10 x double]* %132, i64 0, i64 4
%134 = load double, double* %133
%135 = fptosi double %134 to i32
%136 = load i32, i32* %34
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [101 x i32], [101 x i32]* %63, i64 0, i64 %137
store i32 %135, i32* %138
%139 = load [10 x double]*, [10 x double]** %16
%140 = load i32, i32* %34
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [10 x double], [10 x double]* %139, i64 %141
%143 = getelementptr inbounds [10 x double], [10 x double]* %142, i64 0, i64 5
%144 = load double, double* %143
%145 = fptosi double %144 to i32
%146 = load i32, i32* %34
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [101 x i32], [101 x i32]* %64, i64 0, i64 %147
store i32 %145, i32* %148
%149 = load [10 x double]*, [10 x double]** %16
%150 = load i32, i32* %34
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [10 x double], [10 x double]* %149, i64 %151
%153 = getelementptr inbounds [10 x double], [10 x double]* %152, i64 0, i64 6
%154 = load double, double* %153
%155 = fptosi double %154 to i32
%156 = load i32, i32* %34
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [101 x i32], [101 x i32]* %65, i64 0, i64 %157
store i32 %155, i32* %158
%159 = load [10 x double]*, [10 x double]** %16
%160 = load i32, i32* %34
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [10 x double], [10 x double]* %159, i64 %161
%163 = getelementptr inbounds [10 x double], [10 x double]* %162, i64 0, i64 7
%164 = load double, double* %163
%165 = fptosi double %164 to i32
%166 = load i32, i32* %34
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [101 x i32], [101 x i32]* %66, i64 0, i64 %167
store i32 %165, i32* %168
%169 = load [10 x double]*, [10 x double]** %16
%170 = load i32, i32* %34
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [10 x double], [10 x double]* %169, i64 %171
%173 = getelementptr inbounds [10 x double], [10 x double]* %172, i64 0, i64 8
%174 = load double, double* %173
%175 = load i32, i32* %34
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %176
store double %174, double* %177
%178 = load [10 x double]*, [10 x double]** %16
%179 = load i32, i32* %34
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [10 x double], [10 x double]* %178, i64 %180
%182 = getelementptr inbounds [10 x double], [10 x double]* %181, i64 0, i64 9
%183 = load double, double* %182
%184 = load i32, i32* %34
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %185
store double %183, double* %186
br label %187
187: ; preds = %98
%188 = load i32, i32* %34
%189 = add nsw i32 %188, 1
store i32 %189, i32* %34
br label %95
190: ; preds = %95
store i32 1, i32* %34
br label %191
191: ; preds = %209, %190
%192 = load i32, i32* %34
%193 = icmp sle i32 %192, 26
br i1 %193, label %194, label %212
194: ; preds = %191
store i32 1, i32* %35
br label %195
195: ; preds = %205, %194
%196 = load i32, i32* %35
%197 = icmp sle i32 %196, 26
br i1 %197, label %198, label %208
198: ; preds = %195
%199 = load i32, i32* %34
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %200
%202 = load i32, i32* %35
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [27 x double], [27 x double]* %201, i64 0, i64 %203
store double 0.000000e+00, double* %204
br label %205
205: ; preds = %198
%206 = load i32, i32* %35
%207 = add nsw i32 %206, 1
store i32 %207, i32* %35
br label %195
208: ; preds = %195
br label %209
209: ; preds = %208
%210 = load i32, i32* %34
%211 = add nsw i32 %210, 1
store i32 %211, i32* %34
br label %191
212: ; preds = %191
store i32 1, i32* %40
br label %213
213: ; preds = %1630, %212
%214 = load i32, i32* %40
%215 = icmp sle i32 %214, 100
br i1 %215, label %216, label %1633
216: ; preds = %213
%217 = load i32, i32* %40
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [101 x i32], [101 x i32]* %60, i64 0, i64 %218
%220 = load i32, i32* %219
store i32 %220, i32* %43
%221 = load i32, i32* %40
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [101 x i32], [101 x i32]* %61, i64 0, i64 %222
%224 = load i32, i32* %223
store i32 %224, i32* %34
%225 = load i32, i32* %40
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds [101 x i32], [101 x i32]* %62, i64 0, i64 %226
%228 = load i32, i32* %227
store i32 %228, i32* %35
%229 = load i32, i32* %40
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [101 x i32], [101 x i32]* %63, i64 0, i64 %230
%232 = load i32, i32* %231
store i32 %232, i32* %36
%233 = load i32, i32* %40
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [101 x i32], [101 x i32]* %64, i64 0, i64 %234
%236 = load i32, i32* %235
store i32 %236, i32* %37
%237 = load i32, i32* %40
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [101 x i32], [101 x i32]* %65, i64 0, i64 %238
%240 = load i32, i32* %239
store i32 %240, i32* %38
%241 = load i32, i32* %40
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [101 x i32], [101 x i32]* %66, i64 0, i64 %242
%244 = load i32, i32* %243
store i32 %244, i32* %39
%245 = load i32, i32* %34
%246 = icmp sle i32 %245, 26
br i1 %246, label %247, label %1629
247: ; preds = %216
%248 = load i32, i32* %39
%249 = icmp sle i32 %248, 26
br i1 %249, label %250, label %1629
250: ; preds = %247
%251 = load i32, i32* %43
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [12 x double], [12 x double]* %28, i64 0, i64 %252
%254 = load double, double* %253
store double %254, double* %50
%255 = load i32, i32* %43
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [12 x double], [12 x double]* %29, i64 0, i64 %256
%258 = load double, double* %257
store double %258, double* %51
%259 = load i32, i32* %43
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [12 x double], [12 x double]* %30, i64 0, i64 %260
%262 = load double, double* %261
store double %262, double* %52
%263 = load i32, i32* %43
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [12 x double], [12 x double]* %31, i64 0, i64 %264
%266 = load double, double* %265
store double %266, double* %53
%267 = load i32, i32* %43
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds [12 x double], [12 x double]* %32, i64 0, i64 %268
%270 = load double, double* %269
store double %270, double* %54
%271 = load i32, i32* %43
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [12 x double], [12 x double]* %33, i64 0, i64 %272
%274 = load double, double* %273
store double %274, double* %55
%275 = load i32, i32* %43
switch i32 %275, label %1142 [
i32 0, label %276
i32 1, label %287
i32 2, label %355
i32 3, label %438
i32 4, label %456
i32 5, label %527
i32 6, label %598
i32 7, label %665
i32 8, label %750
i32 9, label %851
i32 10, label %934
i32 11, label %1023
]
276: ; preds = %250
%277 = load double*, double** %17
%278 = load i32, i32* %40
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %277, i64 %279
%281 = load double, double* %280
store double %281, double* %44
store double 0.000000e+00, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %48
%282 = load double*, double** %18
%283 = load i32, i32* %40
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
%286 = load double, double* %285
store double %286, double* %49
br label %1142
287: ; preds = %250
%288 = load i32, i32* %40
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %289
%291 = load double, double* %290
%292 = fmul double %291, 9.870000e+09
%293 = load double, double* %15
%294 = call double @pow(double %293, double 1.500000e+00)
%295 = fmul double %292, %294
%296 = load i32, i32* %40
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %297
%299 = load double, double* %298
%300 = fneg double %299
%301 = load double, double* %15
%302 = fdiv double %300, %301
%303 = call double @exp(double %302)
%304 = fmul double %295, %303
%305 = load double*, double** %17
%306 = load i32, i32* %40
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %305, i64 %307
%309 = load double, double* %308
%310 = fmul double %304, %309
%311 = load double*, double** %18
%312 = load i32, i32* %40
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %311, i64 %313
store double %310, double* %314
%315 = load double, double* %27
%316 = load double*, double** %17
%317 = load i32, i32* %40
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = fmul double %315, %320
%322 = load double*, double** %17
%323 = load i32, i32* %40
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %322, i64 %324
store double %321, double* %325
%326 = load double*, double** %24
%327 = load i32, i32* %35
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %326, i64 %328
%330 = load double, double* %329
%331 = load double*, double** %17
%332 = load i32, i32* %40
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %331, i64 %333
%335 = load double, double* %334
%336 = fmul double %330, %335
%337 = fdiv double %336, 2.000000e+00
store double %337, double* %44
%338 = load double*, double** %24
%339 = load i32, i32* %34
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds double, double* %338, i64 %340
%342 = load double, double* %341
%343 = load double*, double** %17
%344 = load i32, i32* %40
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %343, i64 %345
%347 = load double, double* %346
%348 = fmul double %342, %347
%349 = fdiv double %348, 2.000000e+00
store double %349, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %48
%350 = load double*, double** %18
%351 = load i32, i32* %40
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %350, i64 %352
%354 = load double, double* %353
store double %354, double* %49
br label %1142
355: ; preds = %250
%356 = load double, double* %27
%357 = load double*, double** %17
%358 = load i32, i32* %40
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %357, i64 %359
%361 = load double, double* %360
%362 = fmul double %356, %361
%363 = load double*, double** %17
%364 = load i32, i32* %40
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %363, i64 %365
store double %362, double* %366
%367 = load i32, i32* %40
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %368
%370 = load double, double* %369
%371 = load i32, i32* %40
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %372
%374 = load double, double* %373
%375 = fneg double %374
%376 = load double, double* %15
%377 = fdiv double %375, %376
%378 = call double @exp(double %377)
%379 = fmul double %370, %378
%380 = load double*, double** %17
%381 = load i32, i32* %40
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double, double* %380, i64 %382
%384 = load double, double* %383
%385 = fmul double %379, %384
%386 = load double*, double** %18
%387 = load i32, i32* %40
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %386, i64 %388
store double %385, double* %389
%390 = load double*, double** %24
%391 = load i32, i32* %35
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds double, double* %390, i64 %392
%394 = load double, double* %393
%395 = load double*, double** %17
%396 = load i32, i32* %40
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double, double* %395, i64 %397
%399 = load double, double* %398
%400 = fmul double %394, %399
%401 = fdiv double %400, 2.000000e+00
store double %401, double* %44
%402 = load double*, double** %24
%403 = load i32, i32* %34
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %402, i64 %404
%406 = load double, double* %405
%407 = load double*, double** %17
%408 = load i32, i32* %40
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %407, i64 %409
%411 = load double, double* %410
%412 = fmul double %406, %411
%413 = fdiv double %412, 2.000000e+00
store double %413, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
%414 = load double*, double** %24
%415 = load i32, i32* %39
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double, double* %414, i64 %416
%418 = load double, double* %417
%419 = load double*, double** %18
%420 = load i32, i32* %40
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds double, double* %419, i64 %421
%423 = load double, double* %422
%424 = fmul double %418, %423
%425 = fdiv double %424, 2.000000e+00
store double %425, double* %48
%426 = load double*, double** %24
%427 = load i32, i32* %38
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %426, i64 %428
%430 = load double, double* %429
%431 = load double*, double** %18
%432 = load i32, i32* %40
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
%436 = fmul double %430, %435
%437 = fdiv double %436, 2.000000e+00
store double %437, double* %49
br label %1142
438: ; preds = %250
%439 = load double*, double** %17
%440 = load i32, i32* %40
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds double, double* %439, i64 %441
%443 = load double, double* %442
store double %443, double* %44
store double 0.000000e+00, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %48
%444 = load double*, double** %24
%445 = load i32, i32* %39
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %444, i64 %446
%448 = load double, double* %447
%449 = load double*, double** %18
%450 = load i32, i32* %40
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds double, double* %449, i64 %451
%453 = load double, double* %452
%454 = fmul double %448, %453
%455 = fdiv double %454, 2.000000e+00
store double %455, double* %49
br label %1142
456: ; preds = %250
%457 = load double, double* %27
%458 = load double*, double** %17
%459 = load i32, i32* %40
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %458, i64 %460
%462 = load double, double* %461
%463 = fmul double %457, %462
%464 = load double*, double** %17
%465 = load i32, i32* %40
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds double, double* %464, i64 %466
store double %463, double* %467
%468 = load i32, i32* %40
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %469
%471 = load double, double* %470
%472 = load i32, i32* %40
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %473
%475 = load double, double* %474
%476 = fneg double %475
%477 = load double, double* %15
%478 = fdiv double %476, %477
%479 = call double @exp(double %478)
%480 = fmul double %471, %479
%481 = load double*, double** %17
%482 = load i32, i32* %40
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
%485 = load double, double* %484
%486 = fmul double %480, %485
%487 = load double*, double** %18
%488 = load i32, i32* %40
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %487, i64 %489
store double %486, double* %490
%491 = load double*, double** %24
%492 = load i32, i32* %35
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds double, double* %491, i64 %493
%495 = load double, double* %494
%496 = load double*, double** %17
%497 = load i32, i32* %40
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds double, double* %496, i64 %498
%500 = load double, double* %499
%501 = fmul double %495, %500
%502 = fdiv double %501, 2.000000e+00
store double %502, double* %44
%503 = load double*, double** %24
%504 = load i32, i32* %34
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds double, double* %503, i64 %505
%507 = load double, double* %506
%508 = load double*, double** %17
%509 = load i32, i32* %40
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds double, double* %508, i64 %510
%512 = load double, double* %511
%513 = fmul double %507, %512
%514 = fdiv double %513, 2.000000e+00
store double %514, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %48
%515 = load double*, double** %24
%516 = load i32, i32* %39
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds double, double* %515, i64 %517
%519 = load double, double* %518
%520 = load double*, double** %18
%521 = load i32, i32* %40
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %520, i64 %522
%524 = load double, double* %523
%525 = fmul double %519, %524
%526 = fdiv double %525, 2.000000e+00
store double %526, double* %49
br label %1142
527: ; preds = %250
%528 = load double, double* %27
%529 = load double*, double** %17
%530 = load i32, i32* %40
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %529, i64 %531
%533 = load double, double* %532
%534 = fmul double %528, %533
%535 = load double*, double** %17
%536 = load i32, i32* %40
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds double, double* %535, i64 %537
store double %534, double* %538
%539 = load i32, i32* %40
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %540
%542 = load double, double* %541
%543 = load i32, i32* %40
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %544
%546 = load double, double* %545
%547 = fneg double %546
%548 = load double, double* %15
%549 = fdiv double %547, %548
%550 = call double @exp(double %549)
%551 = fmul double %542, %550
%552 = load double*, double** %17
%553 = load i32, i32* %40
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds double, double* %552, i64 %554
%556 = load double, double* %555
%557 = fmul double %551, %556
%558 = load double*, double** %18
%559 = load i32, i32* %40
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %558, i64 %560
store double %557, double* %561
%562 = load double*, double** %24
%563 = load i32, i32* %34
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds double, double* %562, i64 %564
%566 = load double, double* %565
%567 = load double*, double** %17
%568 = load i32, i32* %40
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %567, i64 %569
%571 = load double, double* %570
%572 = fmul double %566, %571
%573 = fdiv double %572, 2.000000e+00
store double %573, double* %44
store double 0.000000e+00, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
%574 = load double*, double** %24
%575 = load i32, i32* %39
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds double, double* %574, i64 %576
%578 = load double, double* %577
%579 = load double*, double** %18
%580 = load i32, i32* %40
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double, double* %579, i64 %581
%583 = load double, double* %582
%584 = fmul double %578, %583
%585 = fdiv double %584, 2.000000e+00
store double %585, double* %48
%586 = load double*, double** %24
%587 = load i32, i32* %38
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds double, double* %586, i64 %588
%590 = load double, double* %589
%591 = load double*, double** %18
%592 = load i32, i32* %40
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds double, double* %591, i64 %593
%595 = load double, double* %594
%596 = fmul double %590, %595
%597 = fdiv double %596, 2.000000e+00
store double %597, double* %49
br label %1142
598: ; preds = %250
%599 = load i32, i32* %40
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %600
%602 = load double, double* %601
%603 = fmul double %602, 9.740000e+19
%604 = load double, double* %15
%605 = call double @pow(double %604, double 1.500000e+00)
%606 = fmul double %603, %605
%607 = load double, double* %15
%608 = call double @pow(double %607, double 1.500000e+00)
%609 = fmul double %606, %608
%610 = load i32, i32* %40
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %611
%613 = load double, double* %612
%614 = fneg double %613
%615 = load double, double* %15
%616 = fdiv double %614, %615
%617 = call double @exp(double %616)
%618 = fmul double %609, %617
%619 = load double*, double** %17
%620 = load i32, i32* %40
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %619, i64 %621
%623 = load double, double* %622
%624 = fmul double %618, %623
%625 = load double*, double** %18
%626 = load i32, i32* %40
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds double, double* %625, i64 %627
store double %624, double* %628
%629 = load double, double* %27
%630 = load double, double* %27
%631 = fmul double %629, %630
%632 = load double*, double** %17
%633 = load i32, i32* %40
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds double, double* %632, i64 %634
%636 = load double, double* %635
%637 = fmul double %631, %636
%638 = load double*, double** %17
%639 = load i32, i32* %40
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds double, double* %638, i64 %640
store double %637, double* %641
%642 = load double*, double** %24
%643 = load i32, i32* %34
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds double, double* %642, i64 %644
%646 = load double, double* %645
%647 = load double*, double** %24
%648 = load i32, i32* %34
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds double, double* %647, i64 %649
%651 = load double, double* %650
%652 = fmul double %646, %651
%653 = load double*, double** %17
%654 = load i32, i32* %40
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds double, double* %653, i64 %655
%657 = load double, double* %656
%658 = fmul double %652, %657
%659 = fdiv double %658, 6.000000e+00
store double %659, double* %44
store double 0.000000e+00, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %48
%660 = load double*, double** %18
%661 = load i32, i32* %40
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds double, double* %660, i64 %662
%664 = load double, double* %663
store double %664, double* %49
br label %1142
665: ; preds = %250
%666 = load i32, i32* %40
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %667
%669 = load double, double* %668
%670 = fmul double %669, 9.740000e+19
%671 = load double, double* %15
%672 = call double @pow(double %671, double 1.500000e+00)
%673 = fmul double %670, %672
%674 = load double, double* %15
%675 = call double @pow(double %674, double 1.500000e+00)
%676 = fmul double %673, %675
%677 = load i32, i32* %40
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %678
%680 = load double, double* %679
%681 = fneg double %680
%682 = load double, double* %15
%683 = fdiv double %681, %682
%684 = call double @exp(double %683)
%685 = fmul double %676, %684
%686 = load double*, double** %17
%687 = load i32, i32* %40
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds double, double* %686, i64 %688
%690 = load double, double* %689
%691 = fmul double %685, %690
%692 = load double*, double** %18
%693 = load i32, i32* %40
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds double, double* %692, i64 %694
store double %691, double* %695
%696 = load double, double* %27
%697 = load double, double* %27
%698 = fmul double %696, %697
%699 = load double*, double** %17
%700 = load i32, i32* %40
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds double, double* %699, i64 %701
%703 = load double, double* %702
%704 = fmul double %698, %703
%705 = load double*, double** %17
%706 = load i32, i32* %40
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds double, double* %705, i64 %707
store double %704, double* %708
%709 = load double*, double** %24
%710 = load i32, i32* %35
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds double, double* %709, i64 %711
%713 = load double, double* %712
%714 = load double*, double** %24
%715 = load i32, i32* %34
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds double, double* %714, i64 %716
%718 = load double, double* %717
%719 = fmul double %713, %718
%720 = load double*, double** %17
%721 = load i32, i32* %40
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double, double* %720, i64 %722
%724 = load double, double* %723
%725 = fmul double %719, %724
%726 = fdiv double %725, 3.000000e+00
store double %726, double* %44
%727 = load double*, double** %24
%728 = load i32, i32* %34
%729 = sext i32 %728 to i64
%730 = getelementptr inbounds double, double* %727, i64 %729
%731 = load double, double* %730
%732 = load double*, double** %24
%733 = load i32, i32* %34
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %732, i64 %734
%736 = load double, double* %735
%737 = fmul double %731, %736
%738 = load double*, double** %17
%739 = load i32, i32* %40
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds double, double* %738, i64 %740
%742 = load double, double* %741
%743 = fmul double %737, %742
%744 = fdiv double %743, 6.000000e+00
store double %744, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %48
%745 = load double*, double** %18
%746 = load i32, i32* %40
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds double, double* %745, i64 %747
%749 = load double, double* %748
store double %749, double* %49
br label %1142
750: ; preds = %250
%751 = load double, double* %27
%752 = load double*, double** %17
%753 = load i32, i32* %40
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds double, double* %752, i64 %754
%756 = load double, double* %755
%757 = fmul double %751, %756
%758 = load double*, double** %17
%759 = load i32, i32* %40
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds double, double* %758, i64 %760
store double %757, double* %761
%762 = load i32, i32* %40
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %763
%765 = load double, double* %764
%766 = fmul double %765, 1.013000e-10
%767 = load double, double* %15
%768 = call double @pow(double %767, double -1.500000e+00)
%769 = fmul double %766, %768
%770 = load double, double* %27
%771 = fmul double %769, %770
%772 = load i32, i32* %40
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %773
%775 = load double, double* %774
%776 = fneg double %775
%777 = load double, double* %15
%778 = fdiv double %776, %777
%779 = call double @exp(double %778)
%780 = fmul double %771, %779
%781 = load double*, double** %17
%782 = load i32, i32* %40
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds double, double* %781, i64 %783
%785 = load double, double* %784
%786 = fmul double %780, %785
%787 = load double*, double** %18
%788 = load i32, i32* %40
%789 = sext i32 %788 to i64
%790 = getelementptr inbounds double, double* %787, i64 %789
store double %786, double* %790
%791 = load double*, double** %24
%792 = load i32, i32* %35
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds double, double* %791, i64 %793
%795 = load double, double* %794
%796 = load double*, double** %17
%797 = load i32, i32* %40
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %796, i64 %798
%800 = load double, double* %799
%801 = fmul double %795, %800
%802 = fdiv double %801, 2.000000e+00
store double %802, double* %44
%803 = load double*, double** %24
%804 = load i32, i32* %34
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds double, double* %803, i64 %805
%807 = load double, double* %806
%808 = load double*, double** %17
%809 = load i32, i32* %40
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds double, double* %808, i64 %810
%812 = load double, double* %811
%813 = fmul double %807, %812
%814 = fdiv double %813, 2.000000e+00
store double %814, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
%815 = load double*, double** %24
%816 = load i32, i32* %39
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds double, double* %815, i64 %817
%819 = load double, double* %818
%820 = load double*, double** %24
%821 = load i32, i32* %39
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds double, double* %820, i64 %822
%824 = load double, double* %823
%825 = fmul double %819, %824
%826 = load double*, double** %18
%827 = load i32, i32* %40
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds double, double* %826, i64 %828
%830 = load double, double* %829
%831 = fmul double %825, %830
%832 = fdiv double %831, 6.000000e+00
store double %832, double* %48
%833 = load double*, double** %24
%834 = load i32, i32* %38
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds double, double* %833, i64 %835
%837 = load double, double* %836
%838 = load double*, double** %24
%839 = load i32, i32* %39
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds double, double* %838, i64 %840
%842 = load double, double* %841
%843 = fmul double %837, %842
%844 = load double*, double** %18
%845 = load i32, i32* %40
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds double, double* %844, i64 %846
%848 = load double, double* %847
%849 = fmul double %843, %848
%850 = fdiv double %849, 3.000000e+00
store double %850, double* %49
br label %1142
851: ; preds = %250
%852 = load double, double* %27
%853 = load double*, double** %17
%854 = load i32, i32* %40
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds double, double* %853, i64 %855
%857 = load double, double* %856
%858 = fmul double %852, %857
%859 = load double*, double** %17
%860 = load i32, i32* %40
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds double, double* %859, i64 %861
store double %858, double* %862
%863 = load i32, i32* %40
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %864
%866 = load double, double* %865
%867 = fmul double %866, 1.013000e-10
%868 = load double, double* %15
%869 = call double @pow(double %868, double -1.500000e+00)
%870 = fmul double %867, %869
%871 = load double, double* %27
%872 = fmul double %870, %871
%873 = load i32, i32* %40
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %874
%876 = load double, double* %875
%877 = fneg double %876
%878 = load double, double* %15
%879 = fdiv double %877, %878
%880 = call double @exp(double %879)
%881 = fmul double %872, %880
%882 = load double*, double** %17
%883 = load i32, i32* %40
%884 = sext i32 %883 to i64
%885 = getelementptr inbounds double, double* %882, i64 %884
%886 = load double, double* %885
%887 = fmul double %881, %886
%888 = load double*, double** %18
%889 = load i32, i32* %40
%890 = sext i32 %889 to i64
%891 = getelementptr inbounds double, double* %888, i64 %890
store double %887, double* %891
%892 = load double*, double** %24
%893 = load i32, i32* %35
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds double, double* %892, i64 %894
%896 = load double, double* %895
%897 = load double*, double** %17
%898 = load i32, i32* %40
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds double, double* %897, i64 %899
%901 = load double, double* %900
%902 = fmul double %896, %901
%903 = fdiv double %902, 2.000000e+00
store double %903, double* %44
%904 = load double*, double** %24
%905 = load i32, i32* %34
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds double, double* %904, i64 %906
%908 = load double, double* %907
%909 = load double*, double** %17
%910 = load i32, i32* %40
%911 = sext i32 %910 to i64
%912 = getelementptr inbounds double, double* %909, i64 %911
%913 = load double, double* %912
%914 = fmul double %908, %913
%915 = fdiv double %914, 2.000000e+00
store double %915, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
store double 0.000000e+00, double* %48
%916 = load double*, double** %24
%917 = load i32, i32* %39
%918 = sext i32 %917 to i64
%919 = getelementptr inbounds double, double* %916, i64 %918
%920 = load double, double* %919
%921 = load double*, double** %24
%922 = load i32, i32* %39
%923 = sext i32 %922 to i64
%924 = getelementptr inbounds double, double* %921, i64 %923
%925 = load double, double* %924
%926 = fmul double %920, %925
%927 = load double*, double** %18
%928 = load i32, i32* %40
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds double, double* %927, i64 %929
%931 = load double, double* %930
%932 = fmul double %926, %931
%933 = fdiv double %932, 6.000000e+00
store double %933, double* %49
br label %1142
934: ; preds = %250
%935 = load double, double* %27
%936 = load double*, double** %17
%937 = load i32, i32* %40
%938 = sext i32 %937 to i64
%939 = getelementptr inbounds double, double* %936, i64 %938
%940 = load double, double* %939
%941 = fmul double %935, %940
%942 = load double*, double** %17
%943 = load i32, i32* %40
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds double, double* %942, i64 %944
store double %941, double* %945
%946 = load i32, i32* %40
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %947
%949 = load double, double* %948
%950 = fmul double %949, 1.013000e-10
%951 = load double, double* %15
%952 = call double @pow(double %951, double -1.500000e+00)
%953 = fmul double %950, %952
%954 = load double, double* %27
%955 = fmul double %953, %954
%956 = load i32, i32* %40
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %957
%959 = load double, double* %958
%960 = fneg double %959
%961 = load double, double* %15
%962 = fdiv double %960, %961
%963 = call double @exp(double %962)
%964 = fmul double %955, %963
%965 = load double*, double** %17
%966 = load i32, i32* %40
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds double, double* %965, i64 %967
%969 = load double, double* %968
%970 = fmul double %964, %969
%971 = load double*, double** %18
%972 = load i32, i32* %40
%973 = sext i32 %972 to i64
%974 = getelementptr inbounds double, double* %971, i64 %973
store double %970, double* %974
%975 = load double*, double** %24
%976 = load i32, i32* %34
%977 = sext i32 %976 to i64
%978 = getelementptr inbounds double, double* %975, i64 %977
%979 = load double, double* %978
%980 = load double*, double** %17
%981 = load i32, i32* %40
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds double, double* %980, i64 %982
%984 = load double, double* %983
%985 = fmul double %979, %984
%986 = fdiv double %985, 2.000000e+00
store double %986, double* %44
store double 0.000000e+00, double* %45
store double 0.000000e+00, double* %46
store double 0.000000e+00, double* %47
%987 = load double*, double** %24
%988 = load i32, i32* %39
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds double, double* %987, i64 %989
%991 = load double, double* %990
%992 = load double*, double** %24
%993 = load i32, i32* %38
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds double, double* %992, i64 %994
%996 = load double, double* %995
%997 = fmul double %991, %996
%998 = load double*, double** %18
%999 = load i32, i32* %40
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds double, double* %998, i64 %1000
%1002 = load double, double* %1001
%1003 = fmul double %997, %1002
%1004 = fdiv double %1003, 3.000000e+00
store double %1004, double* %48
%1005 = load double*, double** %24
%1006 = load i32, i32* %38
%1007 = sext i32 %1006 to i64
%1008 = getelementptr inbounds double, double* %1005, i64 %1007
%1009 = load double, double* %1008
%1010 = load double*, double** %24
%1011 = load i32, i32* %38
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds double, double* %1010, i64 %1012
%1014 = load double, double* %1013
%1015 = fmul double %1009, %1014
%1016 = load double*, double** %18
%1017 = load i32, i32* %40
%1018 = sext i32 %1017 to i64
%1019 = getelementptr inbounds double, double* %1016, i64 %1018
%1020 = load double, double* %1019
%1021 = fmul double %1015, %1020
%1022 = fdiv double %1021, 6.000000e+00
store double %1022, double* %49
br label %1142
1023: ; preds = %250
%1024 = load double, double* %27
%1025 = load double*, double** %17
%1026 = load i32, i32* %40
%1027 = sext i32 %1026 to i64
%1028 = getelementptr inbounds double, double* %1025, i64 %1027
%1029 = load double, double* %1028
%1030 = fmul double %1024, %1029
%1031 = load double*, double** %17
%1032 = load i32, i32* %40
%1033 = sext i32 %1032 to i64
%1034 = getelementptr inbounds double, double* %1031, i64 %1033
store double %1030, double* %1034
%1035 = load i32, i32* %40
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds [101 x double], [101 x double]* %67, i64 0, i64 %1036
%1038 = load double, double* %1037
%1039 = fmul double %1038, 1.013000e-10
%1040 = load double, double* %15
%1041 = call double @pow(double %1040, double -1.500000e+00)
%1042 = fmul double %1039, %1041
%1043 = load double, double* %27
%1044 = fmul double %1042, %1043
%1045 = load i32, i32* %40
%1046 = sext i32 %1045 to i64
%1047 = getelementptr inbounds [101 x double], [101 x double]* %68, i64 0, i64 %1046
%1048 = load double, double* %1047
%1049 = fneg double %1048
%1050 = load double, double* %15
%1051 = fdiv double %1049, %1050
%1052 = call double @exp(double %1051)
%1053 = fmul double %1044, %1052
%1054 = load double*, double** %17
%1055 = load i32, i32* %40
%1056 = sext i32 %1055 to i64
%1057 = getelementptr inbounds double, double* %1054, i64 %1056
%1058 = load double, double* %1057
%1059 = fmul double %1053, %1058
%1060 = load double*, double** %18
%1061 = load i32, i32* %40
%1062 = sext i32 %1061 to i64
%1063 = getelementptr inbounds double, double* %1060, i64 %1062
store double %1059, double* %1063
%1064 = load double*, double** %24
%1065 = load i32, i32* %35
%1066 = sext i32 %1065 to i64
%1067 = getelementptr inbounds double, double* %1064, i64 %1066
%1068 = load double, double* %1067
%1069 = load double*, double** %17
%1070 = load i32, i32* %40
%1071 = sext i32 %1070 to i64
%1072 = getelementptr inbounds double, double* %1069, i64 %1071
%1073 = load double, double* %1072
%1074 = fmul double %1068, %1073
%1075 = fdiv double %1074, 2.000000e+00
store double %1075, double* %44
%1076 = load double*, double** %24
%1077 = load i32, i32* %34
%1078 = sext i32 %1077 to i64
%1079 = getelementptr inbounds double, double* %1076, i64 %1078
%1080 = load double, double* %1079
%1081 = load double*, double** %17
%1082 = load i32, i32* %40
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds double, double* %1081, i64 %1083
%1085 = load double, double* %1084
%1086 = fmul double %1080, %1085
%1087 = fdiv double %1086, 2.000000e+00
store double %1087, double* %45
store double 0.000000e+00, double* %46
%1088 = load double*, double** %24
%1089 = load i32, i32* %38
%1090 = sext i32 %1089 to i64
%1091 = getelementptr inbounds double, double* %1088, i64 %1090
%1092 = load double, double* %1091
%1093 = load double*, double** %24
%1094 = load i32, i32* %39
%1095 = sext i32 %1094 to i64
%1096 = getelementptr inbounds double, double* %1093, i64 %1095
%1097 = load double, double* %1096
%1098 = fmul double %1092, %1097
%1099 = load double*, double** %18
%1100 = load i32, i32* %40
%1101 = sext i32 %1100 to i64
%1102 = getelementptr inbounds double, double* %1099, i64 %1101
%1103 = load double, double* %1102
%1104 = fmul double %1098, %1103
%1105 = fdiv double %1104, 3.000000e+00
store double %1105, double* %47
%1106 = load double*, double** %24
%1107 = load i32, i32* %37
%1108 = sext i32 %1107 to i64
%1109 = getelementptr inbounds double, double* %1106, i64 %1108
%1110 = load double, double* %1109
%1111 = load double*, double** %24
%1112 = load i32, i32* %39
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds double, double* %1111, i64 %1113
%1115 = load double, double* %1114
%1116 = fmul double %1110, %1115
%1117 = load double*, double** %18
%1118 = load i32, i32* %40
%1119 = sext i32 %1118 to i64
%1120 = getelementptr inbounds double, double* %1117, i64 %1119
%1121 = load double, double* %1120
%1122 = fmul double %1116, %1121
%1123 = fdiv double %1122, 3.000000e+00
store double %1123, double* %48
%1124 = load double*, double** %24
%1125 = load i32, i32* %37
%1126 = sext i32 %1125 to i64
%1127 = getelementptr inbounds double, double* %1124, i64 %1126
%1128 = load double, double* %1127
%1129 = load double*, double** %24
%1130 = load i32, i32* %38
%1131 = sext i32 %1130 to i64
%1132 = getelementptr inbounds double, double* %1129, i64 %1131
%1133 = load double, double* %1132
%1134 = fmul double %1128, %1133
%1135 = load double*, double** %18
%1136 = load i32, i32* %40
%1137 = sext i32 %1136 to i64
%1138 = getelementptr inbounds double, double* %1135, i64 %1137
%1139 = load double, double* %1138
%1140 = fmul double %1134, %1139
%1141 = fdiv double %1140, 3.000000e+00
store double %1141, double* %49
br label %1142
1142: ; preds = %1023, %250, %934, %851, %750, %665, %598, %527, %456, %438, %355, %287, %276
%1143 = load i32, i32* %34
%1144 = sub nsw i32 27, %1143
store i32 %1144, i32* %34
%1145 = load i32, i32* %35
%1146 = sub nsw i32 27, %1145
store i32 %1146, i32* %35
%1147 = load i32, i32* %36
%1148 = sub nsw i32 27, %1147
store i32 %1148, i32* %36
%1149 = load i32, i32* %37
%1150 = sub nsw i32 27, %1149
store i32 %1150, i32* %37
%1151 = load i32, i32* %38
%1152 = sub nsw i32 27, %1151
store i32 %1152, i32* %38
%1153 = load i32, i32* %39
%1154 = sub nsw i32 27, %1153
store i32 %1154, i32* %39
%1155 = load double, double* %50
%1156 = load double, double* %44
%1157 = load i32, i32* %34
%1158 = sext i32 %1157 to i64
%1159 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1158
%1160 = load i32, i32* %34
%1161 = sext i32 %1160 to i64
%1162 = getelementptr inbounds [27 x double], [27 x double]* %1159, i64 0, i64 %1161
%1163 = load double, double* %1162
%1164 = call double @llvm.fmuladd.f64(double %1155, double %1156, double %1163)
store double %1164, double* %1162
%1165 = load i32, i32* %35
%1166 = icmp sle i32 %1165, 26
br i1 %1166, label %1167, label %1178
1167: ; preds = %1142
%1168 = load double, double* %51
%1169 = load double, double* %44
%1170 = load i32, i32* %35
%1171 = sext i32 %1170 to i64
%1172 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1171
%1173 = load i32, i32* %34
%1174 = sext i32 %1173 to i64
%1175 = getelementptr inbounds [27 x double], [27 x double]* %1172, i64 0, i64 %1174
%1176 = load double, double* %1175
%1177 = call double @llvm.fmuladd.f64(double %1168, double %1169, double %1176)
store double %1177, double* %1175
br label %1178
1178: ; preds = %1167, %1142
%1179 = load i32, i32* %36
%1180 = icmp sle i32 %1179, 26
br i1 %1180, label %1181, label %1192
1181: ; preds = %1178
%1182 = load double, double* %52
%1183 = load double, double* %44
%1184 = load i32, i32* %36
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1185
%1187 = load i32, i32* %34
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds [27 x double], [27 x double]* %1186, i64 0, i64 %1188
%1190 = load double, double* %1189
%1191 = call double @llvm.fmuladd.f64(double %1182, double %1183, double %1190)
store double %1191, double* %1189
br label %1192
1192: ; preds = %1181, %1178
%1193 = load i32, i32* %37
%1194 = icmp sle i32 %1193, 26
br i1 %1194, label %1195, label %1207
1195: ; preds = %1192
%1196 = load double, double* %53
%1197 = load double, double* %44
%1198 = load i32, i32* %37
%1199 = sext i32 %1198 to i64
%1200 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1199
%1201 = load i32, i32* %34
%1202 = sext i32 %1201 to i64
%1203 = getelementptr inbounds [27 x double], [27 x double]* %1200, i64 0, i64 %1202
%1204 = load double, double* %1203
%1205 = fneg double %1196
%1206 = call double @llvm.fmuladd.f64(double %1205, double %1197, double %1204)
store double %1206, double* %1203
br label %1207
1207: ; preds = %1195, %1192
%1208 = load i32, i32* %38
%1209 = icmp sle i32 %1208, 26
br i1 %1209, label %1210, label %1222
1210: ; preds = %1207
%1211 = load double, double* %54
%1212 = load double, double* %44
%1213 = load i32, i32* %38
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1214
%1216 = load i32, i32* %34
%1217 = sext i32 %1216 to i64
%1218 = getelementptr inbounds [27 x double], [27 x double]* %1215, i64 0, i64 %1217
%1219 = load double, double* %1218
%1220 = fneg double %1211
%1221 = call double @llvm.fmuladd.f64(double %1220, double %1212, double %1219)
store double %1221, double* %1218
br label %1222
1222: ; preds = %1210, %1207
%1223 = load double, double* %55
%1224 = load double, double* %44
%1225 = load i32, i32* %39
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1226
%1228 = load i32, i32* %34
%1229 = sext i32 %1228 to i64
%1230 = getelementptr inbounds [27 x double], [27 x double]* %1227, i64 0, i64 %1229
%1231 = load double, double* %1230
%1232 = fneg double %1223
%1233 = call double @llvm.fmuladd.f64(double %1232, double %1224, double %1231)
store double %1233, double* %1230
%1234 = load i32, i32* %35
%1235 = icmp sle i32 %1234, 26
br i1 %1235, label %1236, label %1312
1236: ; preds = %1222
%1237 = load double, double* %50
%1238 = load double, double* %45
%1239 = load i32, i32* %34
%1240 = sext i32 %1239 to i64
%1241 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1240
%1242 = load i32, i32* %35
%1243 = sext i32 %1242 to i64
%1244 = getelementptr inbounds [27 x double], [27 x double]* %1241, i64 0, i64 %1243
%1245 = load double, double* %1244
%1246 = call double @llvm.fmuladd.f64(double %1237, double %1238, double %1245)
store double %1246, double* %1244
%1247 = load double, double* %51
%1248 = load double, double* %45
%1249 = load i32, i32* %35
%1250 = sext i32 %1249 to i64
%1251 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1250
%1252 = load i32, i32* %35
%1253 = sext i32 %1252 to i64
%1254 = getelementptr inbounds [27 x double], [27 x double]* %1251, i64 0, i64 %1253
%1255 = load double, double* %1254
%1256 = call double @llvm.fmuladd.f64(double %1247, double %1248, double %1255)
store double %1256, double* %1254
%1257 = load i32, i32* %36
%1258 = icmp sle i32 %1257, 26
br i1 %1258, label %1259, label %1270
1259: ; preds = %1236
%1260 = load double, double* %52
%1261 = load double, double* %45
%1262 = load i32, i32* %36
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1263
%1265 = load i32, i32* %35
%1266 = sext i32 %1265 to i64
%1267 = getelementptr inbounds [27 x double], [27 x double]* %1264, i64 0, i64 %1266
%1268 = load double, double* %1267
%1269 = call double @llvm.fmuladd.f64(double %1260, double %1261, double %1268)
store double %1269, double* %1267
br label %1270
1270: ; preds = %1259, %1236
%1271 = load i32, i32* %37
%1272 = icmp sle i32 %1271, 26
br i1 %1272, label %1273, label %1285
1273: ; preds = %1270
%1274 = load double, double* %53
%1275 = load double, double* %45
%1276 = load i32, i32* %37
%1277 = sext i32 %1276 to i64
%1278 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1277
%1279 = load i32, i32* %35
%1280 = sext i32 %1279 to i64
%1281 = getelementptr inbounds [27 x double], [27 x double]* %1278, i64 0, i64 %1280
%1282 = load double, double* %1281
%1283 = fneg double %1274
%1284 = call double @llvm.fmuladd.f64(double %1283, double %1275, double %1282)
store double %1284, double* %1281
br label %1285
1285: ; preds = %1273, %1270
%1286 = load i32, i32* %38
%1287 = icmp sle i32 %1286, 26
br i1 %1287, label %1288, label %1300
1288: ; preds = %1285
%1289 = load double, double* %54
%1290 = load double, double* %45
%1291 = load i32, i32* %38
%1292 = sext i32 %1291 to i64
%1293 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1292
%1294 = load i32, i32* %35
%1295 = sext i32 %1294 to i64
%1296 = getelementptr inbounds [27 x double], [27 x double]* %1293, i64 0, i64 %1295
%1297 = load double, double* %1296
%1298 = fneg double %1289
%1299 = call double @llvm.fmuladd.f64(double %1298, double %1290, double %1297)
store double %1299, double* %1296
br label %1300
1300: ; preds = %1288, %1285
%1301 = load double, double* %55
%1302 = load double, double* %45
%1303 = load i32, i32* %39
%1304 = sext i32 %1303 to i64
%1305 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1304
%1306 = load i32, i32* %35
%1307 = sext i32 %1306 to i64
%1308 = getelementptr inbounds [27 x double], [27 x double]* %1305, i64 0, i64 %1307
%1309 = load double, double* %1308
%1310 = fneg double %1301
%1311 = call double @llvm.fmuladd.f64(double %1310, double %1302, double %1309)
store double %1311, double* %1308
br label %1312
1312: ; preds = %1300, %1222
%1313 = load i32, i32* %36
%1314 = icmp sle i32 %1313, 26
br i1 %1314, label %1315, label %1391
1315: ; preds = %1312
%1316 = load double, double* %50
%1317 = load double, double* %46
%1318 = load i32, i32* %34
%1319 = sext i32 %1318 to i64
%1320 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1319
%1321 = load i32, i32* %36
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds [27 x double], [27 x double]* %1320, i64 0, i64 %1322
%1324 = load double, double* %1323
%1325 = call double @llvm.fmuladd.f64(double %1316, double %1317, double %1324)
store double %1325, double* %1323
%1326 = load i32, i32* %35
%1327 = icmp sle i32 %1326, 26
br i1 %1327, label %1328, label %1339
1328: ; preds = %1315
%1329 = load double, double* %51
%1330 = load double, double* %46
%1331 = load i32, i32* %35
%1332 = sext i32 %1331 to i64
%1333 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1332
%1334 = load i32, i32* %36
%1335 = sext i32 %1334 to i64
%1336 = getelementptr inbounds [27 x double], [27 x double]* %1333, i64 0, i64 %1335
%1337 = load double, double* %1336
%1338 = call double @llvm.fmuladd.f64(double %1329, double %1330, double %1337)
store double %1338, double* %1336
br label %1339
1339: ; preds = %1328, %1315
%1340 = load double, double* %52
%1341 = load double, double* %46
%1342 = load i32, i32* %36
%1343 = sext i32 %1342 to i64
%1344 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1343
%1345 = load i32, i32* %36
%1346 = sext i32 %1345 to i64
%1347 = getelementptr inbounds [27 x double], [27 x double]* %1344, i64 0, i64 %1346
%1348 = load double, double* %1347
%1349 = call double @llvm.fmuladd.f64(double %1340, double %1341, double %1348)
store double %1349, double* %1347
%1350 = load i32, i32* %37
%1351 = icmp sle i32 %1350, 26
br i1 %1351, label %1352, label %1364
1352: ; preds = %1339
%1353 = load double, double* %53
%1354 = load double, double* %46
%1355 = load i32, i32* %37
%1356 = sext i32 %1355 to i64
%1357 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1356
%1358 = load i32, i32* %36
%1359 = sext i32 %1358 to i64
%1360 = getelementptr inbounds [27 x double], [27 x double]* %1357, i64 0, i64 %1359
%1361 = load double, double* %1360
%1362 = fneg double %1353
%1363 = call double @llvm.fmuladd.f64(double %1362, double %1354, double %1361)
store double %1363, double* %1360
br label %1364
1364: ; preds = %1352, %1339
%1365 = load i32, i32* %38
%1366 = icmp sle i32 %1365, 26
br i1 %1366, label %1367, label %1379
1367: ; preds = %1364
%1368 = load double, double* %54
%1369 = load double, double* %46
%1370 = load i32, i32* %38
%1371 = sext i32 %1370 to i64
%1372 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1371
%1373 = load i32, i32* %36
%1374 = sext i32 %1373 to i64
%1375 = getelementptr inbounds [27 x double], [27 x double]* %1372, i64 0, i64 %1374
%1376 = load double, double* %1375
%1377 = fneg double %1368
%1378 = call double @llvm.fmuladd.f64(double %1377, double %1369, double %1376)
store double %1378, double* %1375
br label %1379
1379: ; preds = %1367, %1364
%1380 = load double, double* %55
%1381 = load double, double* %46
%1382 = load i32, i32* %39
%1383 = sext i32 %1382 to i64
%1384 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1383
%1385 = load i32, i32* %36
%1386 = sext i32 %1385 to i64
%1387 = getelementptr inbounds [27 x double], [27 x double]* %1384, i64 0, i64 %1386
%1388 = load double, double* %1387
%1389 = fneg double %1380
%1390 = call double @llvm.fmuladd.f64(double %1389, double %1381, double %1388)
store double %1390, double* %1387
br label %1391
1391: ; preds = %1379, %1312
%1392 = load i32, i32* %37
%1393 = icmp sle i32 %1392, 26
br i1 %1393, label %1394, label %1470
1394: ; preds = %1391
%1395 = load double, double* %50
%1396 = load double, double* %47
%1397 = load i32, i32* %34
%1398 = sext i32 %1397 to i64
%1399 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1398
%1400 = load i32, i32* %37
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds [27 x double], [27 x double]* %1399, i64 0, i64 %1401
%1403 = load double, double* %1402
%1404 = fneg double %1395
%1405 = call double @llvm.fmuladd.f64(double %1404, double %1396, double %1403)
store double %1405, double* %1402
%1406 = load i32, i32* %35
%1407 = icmp sle i32 %1406, 26
br i1 %1407, label %1408, label %1420
1408: ; preds = %1394
%1409 = load double, double* %51
%1410 = load double, double* %47
%1411 = load i32, i32* %35
%1412 = sext i32 %1411 to i64
%1413 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1412
%1414 = load i32, i32* %37
%1415 = sext i32 %1414 to i64
%1416 = getelementptr inbounds [27 x double], [27 x double]* %1413, i64 0, i64 %1415
%1417 = load double, double* %1416
%1418 = fneg double %1409
%1419 = call double @llvm.fmuladd.f64(double %1418, double %1410, double %1417)
store double %1419, double* %1416
br label %1420
1420: ; preds = %1408, %1394
%1421 = load i32, i32* %36
%1422 = icmp sle i32 %1421, 26
br i1 %1422, label %1423, label %1435
1423: ; preds = %1420
%1424 = load double, double* %52
%1425 = load double, double* %47
%1426 = load i32, i32* %36
%1427 = sext i32 %1426 to i64
%1428 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1427
%1429 = load i32, i32* %37
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds [27 x double], [27 x double]* %1428, i64 0, i64 %1430
%1432 = load double, double* %1431
%1433 = fneg double %1424
%1434 = call double @llvm.fmuladd.f64(double %1433, double %1425, double %1432)
store double %1434, double* %1431
br label %1435
1435: ; preds = %1423, %1420
%1436 = load double, double* %53
%1437 = load double, double* %47
%1438 = load i32, i32* %37
%1439 = sext i32 %1438 to i64
%1440 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1439
%1441 = load i32, i32* %37
%1442 = sext i32 %1441 to i64
%1443 = getelementptr inbounds [27 x double], [27 x double]* %1440, i64 0, i64 %1442
%1444 = load double, double* %1443
%1445 = call double @llvm.fmuladd.f64(double %1436, double %1437, double %1444)
store double %1445, double* %1443
%1446 = load i32, i32* %38
%1447 = icmp sle i32 %1446, 26
br i1 %1447, label %1448, label %1459
1448: ; preds = %1435
%1449 = load double, double* %54
%1450 = load double, double* %47
%1451 = load i32, i32* %38
%1452 = sext i32 %1451 to i64
%1453 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1452
%1454 = load i32, i32* %37
%1455 = sext i32 %1454 to i64
%1456 = getelementptr inbounds [27 x double], [27 x double]* %1453, i64 0, i64 %1455
%1457 = load double, double* %1456
%1458 = call double @llvm.fmuladd.f64(double %1449, double %1450, double %1457)
store double %1458, double* %1456
br label %1459
1459: ; preds = %1448, %1435
%1460 = load double, double* %55
%1461 = load double, double* %47
%1462 = load i32, i32* %39
%1463 = sext i32 %1462 to i64
%1464 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1463
%1465 = load i32, i32* %37
%1466 = sext i32 %1465 to i64
%1467 = getelementptr inbounds [27 x double], [27 x double]* %1464, i64 0, i64 %1466
%1468 = load double, double* %1467
%1469 = call double @llvm.fmuladd.f64(double %1460, double %1461, double %1468)
store double %1469, double* %1467
br label %1470
1470: ; preds = %1459, %1391
%1471 = load i32, i32* %38
%1472 = icmp sle i32 %1471, 26
br i1 %1472, label %1473, label %1549
1473: ; preds = %1470
%1474 = load double, double* %50
%1475 = load double, double* %48
%1476 = load i32, i32* %34
%1477 = sext i32 %1476 to i64
%1478 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1477
%1479 = load i32, i32* %38
%1480 = sext i32 %1479 to i64
%1481 = getelementptr inbounds [27 x double], [27 x double]* %1478, i64 0, i64 %1480
%1482 = load double, double* %1481
%1483 = fneg double %1474
%1484 = call double @llvm.fmuladd.f64(double %1483, double %1475, double %1482)
store double %1484, double* %1481
%1485 = load i32, i32* %35
%1486 = icmp sle i32 %1485, 26
br i1 %1486, label %1487, label %1499
1487: ; preds = %1473
%1488 = load double, double* %51
%1489 = load double, double* %48
%1490 = load i32, i32* %35
%1491 = sext i32 %1490 to i64
%1492 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1491
%1493 = load i32, i32* %38
%1494 = sext i32 %1493 to i64
%1495 = getelementptr inbounds [27 x double], [27 x double]* %1492, i64 0, i64 %1494
%1496 = load double, double* %1495
%1497 = fneg double %1488
%1498 = call double @llvm.fmuladd.f64(double %1497, double %1489, double %1496)
store double %1498, double* %1495
br label %1499
1499: ; preds = %1487, %1473
%1500 = load i32, i32* %36
%1501 = icmp sle i32 %1500, 26
br i1 %1501, label %1502, label %1514
1502: ; preds = %1499
%1503 = load double, double* %52
%1504 = load double, double* %48
%1505 = load i32, i32* %36
%1506 = sext i32 %1505 to i64
%1507 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1506
%1508 = load i32, i32* %38
%1509 = sext i32 %1508 to i64
%1510 = getelementptr inbounds [27 x double], [27 x double]* %1507, i64 0, i64 %1509
%1511 = load double, double* %1510
%1512 = fneg double %1503
%1513 = call double @llvm.fmuladd.f64(double %1512, double %1504, double %1511)
store double %1513, double* %1510
br label %1514
1514: ; preds = %1502, %1499
%1515 = load i32, i32* %37
%1516 = icmp sle i32 %1515, 26
br i1 %1516, label %1517, label %1528
1517: ; preds = %1514
%1518 = load double, double* %53
%1519 = load double, double* %48
%1520 = load i32, i32* %37
%1521 = sext i32 %1520 to i64
%1522 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1521
%1523 = load i32, i32* %38
%1524 = sext i32 %1523 to i64
%1525 = getelementptr inbounds [27 x double], [27 x double]* %1522, i64 0, i64 %1524
%1526 = load double, double* %1525
%1527 = call double @llvm.fmuladd.f64(double %1518, double %1519, double %1526)
store double %1527, double* %1525
br label %1528
1528: ; preds = %1517, %1514
%1529 = load double, double* %54
%1530 = load double, double* %48
%1531 = load i32, i32* %38
%1532 = sext i32 %1531 to i64
%1533 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1532
%1534 = load i32, i32* %38
%1535 = sext i32 %1534 to i64
%1536 = getelementptr inbounds [27 x double], [27 x double]* %1533, i64 0, i64 %1535
%1537 = load double, double* %1536
%1538 = call double @llvm.fmuladd.f64(double %1529, double %1530, double %1537)
store double %1538, double* %1536
%1539 = load double, double* %55
%1540 = load double, double* %48
%1541 = load i32, i32* %39
%1542 = sext i32 %1541 to i64
%1543 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1542
%1544 = load i32, i32* %38
%1545 = sext i32 %1544 to i64
%1546 = getelementptr inbounds [27 x double], [27 x double]* %1543, i64 0, i64 %1545
%1547 = load double, double* %1546
%1548 = call double @llvm.fmuladd.f64(double %1539, double %1540, double %1547)
store double %1548, double* %1546
br label %1549
1549: ; preds = %1528, %1470
%1550 = load double, double* %50
%1551 = load double, double* %49
%1552 = load i32, i32* %34
%1553 = sext i32 %1552 to i64
%1554 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1553
%1555 = load i32, i32* %39
%1556 = sext i32 %1555 to i64
%1557 = getelementptr inbounds [27 x double], [27 x double]* %1554, i64 0, i64 %1556
%1558 = load double, double* %1557
%1559 = fneg double %1550
%1560 = call double @llvm.fmuladd.f64(double %1559, double %1551, double %1558)
store double %1560, double* %1557
%1561 = load i32, i32* %35
%1562 = icmp sle i32 %1561, 26
br i1 %1562, label %1563, label %1575
1563: ; preds = %1549
%1564 = load double, double* %51
%1565 = load double, double* %49
%1566 = load i32, i32* %35
%1567 = sext i32 %1566 to i64
%1568 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1567
%1569 = load i32, i32* %39
%1570 = sext i32 %1569 to i64
%1571 = getelementptr inbounds [27 x double], [27 x double]* %1568, i64 0, i64 %1570
%1572 = load double, double* %1571
%1573 = fneg double %1564
%1574 = call double @llvm.fmuladd.f64(double %1573, double %1565, double %1572)
store double %1574, double* %1571
br label %1575
1575: ; preds = %1563, %1549
%1576 = load i32, i32* %36
%1577 = icmp sle i32 %1576, 26
br i1 %1577, label %1578, label %1590
1578: ; preds = %1575
%1579 = load double, double* %52
%1580 = load double, double* %49
%1581 = load i32, i32* %36
%1582 = sext i32 %1581 to i64
%1583 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1582
%1584 = load i32, i32* %39
%1585 = sext i32 %1584 to i64
%1586 = getelementptr inbounds [27 x double], [27 x double]* %1583, i64 0, i64 %1585
%1587 = load double, double* %1586
%1588 = fneg double %1579
%1589 = call double @llvm.fmuladd.f64(double %1588, double %1580, double %1587)
store double %1589, double* %1586
br label %1590
1590: ; preds = %1578, %1575
%1591 = load i32, i32* %37
%1592 = icmp sle i32 %1591, 26
br i1 %1592, label %1593, label %1604
1593: ; preds = %1590
%1594 = load double, double* %53
%1595 = load double, double* %49
%1596 = load i32, i32* %37
%1597 = sext i32 %1596 to i64
%1598 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1597
%1599 = load i32, i32* %39
%1600 = sext i32 %1599 to i64
%1601 = getelementptr inbounds [27 x double], [27 x double]* %1598, i64 0, i64 %1600
%1602 = load double, double* %1601
%1603 = call double @llvm.fmuladd.f64(double %1594, double %1595, double %1602)
store double %1603, double* %1601
br label %1604
1604: ; preds = %1593, %1590
%1605 = load i32, i32* %38
%1606 = icmp sle i32 %1605, 26
br i1 %1606, label %1607, label %1618
1607: ; preds = %1604
%1608 = load double, double* %54
%1609 = load double, double* %49
%1610 = load i32, i32* %38
%1611 = sext i32 %1610 to i64
%1612 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1611
%1613 = load i32, i32* %39
%1614 = sext i32 %1613 to i64
%1615 = getelementptr inbounds [27 x double], [27 x double]* %1612, i64 0, i64 %1614
%1616 = load double, double* %1615
%1617 = call double @llvm.fmuladd.f64(double %1608, double %1609, double %1616)
store double %1617, double* %1615
br label %1618
1618: ; preds = %1607, %1604
%1619 = load double, double* %55
%1620 = load double, double* %49
%1621 = load i32, i32* %39
%1622 = sext i32 %1621 to i64
%1623 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1622
%1624 = load i32, i32* %39
%1625 = sext i32 %1624 to i64
%1626 = getelementptr inbounds [27 x double], [27 x double]* %1623, i64 0, i64 %1625
%1627 = load double, double* %1626
%1628 = call double @llvm.fmuladd.f64(double %1619, double %1620, double %1627)
store double %1628, double* %1626
br label %1629
1629: ; preds = %1618, %247, %216
br label %1630
1630: ; preds = %1629
%1631 = load i32, i32* %40
%1632 = add nsw i32 %1631, 1
store i32 %1632, i32* %40
br label %213
1633: ; preds = %213
%1634 = load double, double* %26
%1635 = fmul double %1634, 3.000000e+00
%1636 = fmul double %1635, 1.000000e-05
store double %1636, double* %58
store i32 1, i32* %34
br label %1637
1637: ; preds = %1709, %1633
%1638 = load i32, i32* %34
%1639 = icmp sle i32 %1638, 26
br i1 %1639, label %1640, label %1712
1640: ; preds = %1637
%1641 = load i32, i32* %34
%1642 = sub nsw i32 27, %1641
store i32 %1642, i32* %41
store i32 1, i32* %35
br label %1643
1643: ; preds = %1689, %1640
%1644 = load i32, i32* %35
%1645 = icmp sle i32 %1644, 26
br i1 %1645, label %1646, label %1692
1646: ; preds = %1643
%1647 = load i32, i32* %35
%1648 = sub nsw i32 27, %1647
store i32 %1648, i32* %42
%1649 = load i32, i32* %35
%1650 = sext i32 %1649 to i64
%1651 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1650
%1652 = load i32, i32* %34
%1653 = sext i32 %1652 to i64
%1654 = getelementptr inbounds [27 x double], [27 x double]* %1651, i64 0, i64 %1653
%1655 = load double, double* %1654
%1656 = call double @llvm.fabs.f64(double %1655)
%1657 = load double, double* %58
%1658 = load double*, double** %23
%1659 = load i32, i32* %42
%1660 = sext i32 %1659 to i64
%1661 = getelementptr inbounds double, double* %1658, i64 %1660
%1662 = load double, double* %1661
%1663 = fmul double %1657, %1662
%1664 = load double*, double** %23
%1665 = load i32, i32* %41
%1666 = sext i32 %1665 to i64
%1667 = getelementptr inbounds double, double* %1664, i64 %1666
%1668 = load double, double* %1667
%1669 = fdiv double %1663, %1668
%1670 = fcmp olt double %1656, %1669
br i1 %1670, label %1671, label %1678
1671: ; preds = %1646
%1672 = load i32, i32* %35
%1673 = sext i32 %1672 to i64
%1674 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1673
%1675 = load i32, i32* %34
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds [27 x double], [27 x double]* %1674, i64 0, i64 %1676
store double 0.000000e+00, double* %1677
br label %1688
1678: ; preds = %1646
%1679 = load double, double* %22
%1680 = load i32, i32* %35
%1681 = sext i32 %1680 to i64
%1682 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1681
%1683 = load i32, i32* %34
%1684 = sext i32 %1683 to i64
%1685 = getelementptr inbounds [27 x double], [27 x double]* %1682, i64 0, i64 %1684
%1686 = load double, double* %1685
%1687 = fmul double %1686, %1679
store double %1687, double* %1685
br label %1688
1688: ; preds = %1678, %1671
br label %1689
1689: ; preds = %1688
%1690 = load i32, i32* %35
%1691 = add nsw i32 %1690, 1
store i32 %1691, i32* %35
br label %1643
1692: ; preds = %1643
%1693 = load i32, i32* %34
%1694 = sext i32 %1693 to i64
%1695 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1694
%1696 = load i32, i32* %34
%1697 = sext i32 %1696 to i64
%1698 = getelementptr inbounds [27 x double], [27 x double]* %1695, i64 0, i64 %1697
%1699 = load double, double* %1698
%1700 = fadd double %1699, 1.000000e+00
store double %1700, double* %1698
%1701 = load double*, double** %23
%1702 = load i32, i32* %34
%1703 = sext i32 %1702 to i64
%1704 = getelementptr inbounds double, double* %1701, i64 %1703
%1705 = load double, double* %1704
%1706 = load i32, i32* %41
%1707 = sext i32 %1706 to i64
%1708 = getelementptr inbounds [27 x double], [27 x double]* %70, i64 0, i64 %1707
store double %1705, double* %1708
br label %1709
1709: ; preds = %1692
%1710 = load i32, i32* %34
%1711 = add nsw i32 %1710, 1
store i32 %1711, i32* %34
br label %1637
1712: ; preds = %1637
%1713 = load i32, i32* %19
%1714 = icmp eq i32 %1713, 1
br i1 %1714, label %1715, label %1717
1715: ; preds = %1712
%1716 = load i32, i32* %21
store i32 %1716, i32* %72
br label %1719
1717: ; preds = %1712
%1718 = load i32, i32* %59
store i32 %1718, i32* %72
br label %1719
1719: ; preds = %1717, %1715
store i32 0, i32* %79
store i32 0, i32* %57
store i32 1, i32* %34
br label %1720
1720: ; preds = %1734, %1719
%1721 = load i32, i32* %34
%1722 = icmp sle i32 %1721, 26
br i1 %1722, label %1723, label %1737
1723: ; preds = %1720
%1724 = load i32, i32* %34
%1725 = sext i32 %1724 to i64
%1726 = getelementptr inbounds [27 x double], [27 x double]* %70, i64 0, i64 %1725
%1727 = load double, double* %1726
%1728 = load i32, i32* %34
%1729 = sext i32 %1728 to i64
%1730 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1729
store double %1727, double* %1730
%1731 = load i32, i32* %34
%1732 = sext i32 %1731 to i64
%1733 = getelementptr inbounds [27 x double], [27 x double]* %71, i64 0, i64 %1732
store double 0.000000e+00, double* %1733
br label %1734
1734: ; preds = %1723
%1735 = load i32, i32* %34
%1736 = add nsw i32 %1735, 1
store i32 %1736, i32* %34
br label %1720
1737: ; preds = %1720
%1738 = load i32, i32* %72
%1739 = load i32, i32* %20
%1740 = icmp eq i32 %1738, %1739
br i1 %1740, label %1741, label %1771
1741: ; preds = %1737
store i32 1, i32* %34
br label %1742
1742: ; preds = %1767, %1741
%1743 = load i32, i32* %34
%1744 = icmp sle i32 %1743, 26
br i1 %1744, label %1745, label %1770
1745: ; preds = %1742
store i32 1, i32* %35
br label %1746
1746: ; preds = %1763, %1745
%1747 = load i32, i32* %35
%1748 = icmp sle i32 %1747, 26
br i1 %1748, label %1749, label %1766
1749: ; preds = %1746
%1750 = load i32, i32* %35
%1751 = sext i32 %1750 to i64
%1752 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1751
%1753 = load i32, i32* %34
%1754 = sext i32 %1753 to i64
%1755 = getelementptr inbounds [27 x double], [27 x double]* %1752, i64 0, i64 %1754
%1756 = load double, double* %1755
%1757 = load i32, i32* %35
%1758 = sext i32 %1757 to i64
%1759 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %74, i64 0, i64 %1758
%1760 = load i32, i32* %34
%1761 = sext i32 %1760 to i64
%1762 = getelementptr inbounds [27 x double], [27 x double]* %1759, i64 0, i64 %1761
store double %1756, double* %1762
br label %1763
1763: ; preds = %1749
%1764 = load i32, i32* %35
%1765 = add nsw i32 %1764, 1
store i32 %1765, i32* %35
br label %1746
1766: ; preds = %1746
br label %1767
1767: ; preds = %1766
%1768 = load i32, i32* %34
%1769 = add nsw i32 %1768, 1
store i32 %1769, i32* %34
br label %1742
1770: ; preds = %1742
br label %1771
1771: ; preds = %1770, %1737
store i32 1, i32* %34
br label %1772
1772: ; preds = %1868, %1771
%1773 = load i32, i32* %34
%1774 = icmp sle i32 %1773, 26
br i1 %1774, label %1775, label %1871
1775: ; preds = %1772
%1776 = load i32, i32* %34
%1777 = sext i32 %1776 to i64
%1778 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1777
%1779 = load i32, i32* %34
%1780 = sext i32 %1779 to i64
%1781 = getelementptr inbounds [27 x double], [27 x double]* %1778, i64 0, i64 %1780
%1782 = load double, double* %1781
%1783 = fcmp oeq double %1782, 0.000000e+00
br i1 %1783, label %1784, label %1787
1784: ; preds = %1775
%1785 = load i32, i32* %34
store i32 %1785, i32* %57
%1786 = load i32, i32* %57
store i32 %1786, i32* %14
br label %2095
1787: ; preds = %1775
%1788 = load i32, i32* %34
%1789 = add nsw i32 %1788, 1
store i32 %1789, i32* %35
br label %1790
1790: ; preds = %1864, %1787
%1791 = load i32, i32* %35
%1792 = icmp sle i32 %1791, 26
br i1 %1792, label %1793, label %1867
1793: ; preds = %1790
%1794 = load i32, i32* %35
%1795 = sext i32 %1794 to i64
%1796 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1795
%1797 = load i32, i32* %34
%1798 = sext i32 %1797 to i64
%1799 = getelementptr inbounds [27 x double], [27 x double]* %1796, i64 0, i64 %1798
%1800 = load double, double* %1799
%1801 = fcmp une double %1800, 0.000000e+00
br i1 %1801, label %1802, label %1863
1802: ; preds = %1793
%1803 = load i32, i32* %35
%1804 = sext i32 %1803 to i64
%1805 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1804
%1806 = load i32, i32* %34
%1807 = sext i32 %1806 to i64
%1808 = getelementptr inbounds [27 x double], [27 x double]* %1805, i64 0, i64 %1807
%1809 = load double, double* %1808
%1810 = load i32, i32* %34
%1811 = sext i32 %1810 to i64
%1812 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1811
%1813 = load i32, i32* %34
%1814 = sext i32 %1813 to i64
%1815 = getelementptr inbounds [27 x double], [27 x double]* %1812, i64 0, i64 %1814
%1816 = load double, double* %1815
%1817 = fdiv double %1809, %1816
store double %1817, double* %75
%1818 = load i32, i32* %34
%1819 = add nsw i32 %1818, 1
store i32 %1819, i32* %38
br label %1820
1820: ; preds = %1841, %1802
%1821 = load i32, i32* %38
%1822 = icmp sle i32 %1821, 26
br i1 %1822, label %1823, label %1844
1823: ; preds = %1820
%1824 = load double, double* %75
%1825 = load i32, i32* %34
%1826 = sext i32 %1825 to i64
%1827 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1826
%1828 = load i32, i32* %38
%1829 = sext i32 %1828 to i64
%1830 = getelementptr inbounds [27 x double], [27 x double]* %1827, i64 0, i64 %1829
%1831 = load double, double* %1830
%1832 = load i32, i32* %35
%1833 = sext i32 %1832 to i64
%1834 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1833
%1835 = load i32, i32* %38
%1836 = sext i32 %1835 to i64
%1837 = getelementptr inbounds [27 x double], [27 x double]* %1834, i64 0, i64 %1836
%1838 = load double, double* %1837
%1839 = fneg double %1824
%1840 = call double @llvm.fmuladd.f64(double %1839, double %1831, double %1838)
store double %1840, double* %1837
br label %1841
1841: ; preds = %1823
%1842 = load i32, i32* %38
%1843 = add nsw i32 %1842, 1
store i32 %1843, i32* %38
br label %1820
1844: ; preds = %1820
%1845 = load double, double* %75
%1846 = load i32, i32* %35
%1847 = sext i32 %1846 to i64
%1848 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1847
%1849 = load i32, i32* %34
%1850 = sext i32 %1849 to i64
%1851 = getelementptr inbounds [27 x double], [27 x double]* %1848, i64 0, i64 %1850
store double %1845, double* %1851
%1852 = load double, double* %75
%1853 = load i32, i32* %34
%1854 = sext i32 %1853 to i64
%1855 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1854
%1856 = load double, double* %1855
%1857 = load i32, i32* %35
%1858 = sext i32 %1857 to i64
%1859 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1858
%1860 = load double, double* %1859
%1861 = fneg double %1852
%1862 = call double @llvm.fmuladd.f64(double %1861, double %1856, double %1860)
store double %1862, double* %1859
br label %1863
1863: ; preds = %1844, %1793
br label %1864
1864: ; preds = %1863
%1865 = load i32, i32* %35
%1866 = add nsw i32 %1865, 1
store i32 %1866, i32* %35
br label %1790
1867: ; preds = %1790
br label %1868
1868: ; preds = %1867
%1869 = load i32, i32* %34
%1870 = add nsw i32 %1869, 1
store i32 %1870, i32* %34
br label %1772
1871: ; preds = %1772
br label %1872
1872: ; preds = %2058, %1871
%1873 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 26
%1874 = getelementptr inbounds [27 x double], [27 x double]* %1873, i64 0, i64 26
%1875 = load double, double* %1874
%1876 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 26
%1877 = load double, double* %1876
%1878 = fdiv double %1877, %1875
store double %1878, double* %1876
%1879 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 26
%1880 = load double, double* %1879
%1881 = getelementptr inbounds [27 x double], [27 x double]* %71, i64 0, i64 26
%1882 = load double, double* %1881
%1883 = fadd double %1882, %1880
store double %1883, double* %1881
store i32 25, i32* %34
br label %1884
1884: ; preds = %1937, %1872
%1885 = load i32, i32* %34
%1886 = icmp sge i32 %1885, 1
br i1 %1886, label %1887, label %1940
1887: ; preds = %1884
store double 0.000000e+00, double* %76
%1888 = load i32, i32* %34
%1889 = add nsw i32 %1888, 1
store i32 %1889, i32* %35
br label %1890
1890: ; preds = %1907, %1887
%1891 = load i32, i32* %35
%1892 = icmp sle i32 %1891, 26
br i1 %1892, label %1893, label %1910
1893: ; preds = %1890
%1894 = load i32, i32* %34
%1895 = sext i32 %1894 to i64
%1896 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1895
%1897 = load i32, i32* %35
%1898 = sext i32 %1897 to i64
%1899 = getelementptr inbounds [27 x double], [27 x double]* %1896, i64 0, i64 %1898
%1900 = load double, double* %1899
%1901 = load i32, i32* %35
%1902 = sext i32 %1901 to i64
%1903 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1902
%1904 = load double, double* %1903
%1905 = load double, double* %76
%1906 = call double @llvm.fmuladd.f64(double %1900, double %1904, double %1905)
store double %1906, double* %76
br label %1907
1907: ; preds = %1893
%1908 = load i32, i32* %35
%1909 = add nsw i32 %1908, 1
store i32 %1909, i32* %35
br label %1890
1910: ; preds = %1890
%1911 = load i32, i32* %34
%1912 = sext i32 %1911 to i64
%1913 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1912
%1914 = load double, double* %1913
%1915 = load double, double* %76
%1916 = fsub double %1914, %1915
%1917 = load i32, i32* %34
%1918 = sext i32 %1917 to i64
%1919 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %1918
%1920 = load i32, i32* %34
%1921 = sext i32 %1920 to i64
%1922 = getelementptr inbounds [27 x double], [27 x double]* %1919, i64 0, i64 %1921
%1923 = load double, double* %1922
%1924 = fdiv double %1916, %1923
%1925 = load i32, i32* %34
%1926 = sext i32 %1925 to i64
%1927 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1926
store double %1924, double* %1927
%1928 = load i32, i32* %34
%1929 = sext i32 %1928 to i64
%1930 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1929
%1931 = load double, double* %1930
%1932 = load i32, i32* %34
%1933 = sext i32 %1932 to i64
%1934 = getelementptr inbounds [27 x double], [27 x double]* %71, i64 0, i64 %1933
%1935 = load double, double* %1934
%1936 = fadd double %1935, %1931
store double %1936, double* %1934
br label %1937
1937: ; preds = %1910
%1938 = load i32, i32* %34
%1939 = add nsw i32 %1938, -1
store i32 %1939, i32* %34
br label %1884
1940: ; preds = %1884
store i32 1, i32* %80
%1941 = load i32, i32* %72
%1942 = load i32, i32* %20
%1943 = icmp eq i32 %1941, %1942
br i1 %1943, label %1944, label %2056
1944: ; preds = %1940
store i32 1, i32* %34
br label %1945
1945: ; preds = %2052, %1944
%1946 = load i32, i32* %34
%1947 = icmp sle i32 %1946, 26
br i1 %1947, label %1948, label %2055
1948: ; preds = %1945
%1949 = load i32, i32* %34
%1950 = sext i32 %1949 to i64
%1951 = getelementptr inbounds [27 x double], [27 x double]* %71, i64 0, i64 %1950
%1952 = load double, double* %1951
%1953 = fcmp une double %1952, 0.000000e+00
br i1 %1953, label %1954, label %2050
1954: ; preds = %1948
%1955 = load i32, i32* %34
%1956 = sext i32 %1955 to i64
%1957 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %1956
%1958 = load double, double* %1957
%1959 = load i32, i32* %34
%1960 = sext i32 %1959 to i64
%1961 = getelementptr inbounds [27 x double], [27 x double]* %71, i64 0, i64 %1960
%1962 = load double, double* %1961
%1963 = fdiv double %1958, %1962
%1964 = call double @llvm.fabs.f64(double %1963)
store double %1964, double* %77
%1965 = load double, double* %77
%1966 = fcmp ogt double %1965, 2.000000e-04
br i1 %1966, label %1967, label %2048
1967: ; preds = %1954
%1968 = load i32, i32* %79
%1969 = icmp slt i32 %1968, 1
br i1 %1969, label %1970, label %2046
1970: ; preds = %1967
%1971 = load i32, i32* %79
%1972 = add nsw i32 %1971, 1
store i32 %1972, i32* %79
store i32 1, i32* %35
br label %1973
1973: ; preds = %2007, %1970
%1974 = load i32, i32* %35
%1975 = icmp sle i32 %1974, 26
br i1 %1975, label %1976, label %2010
1976: ; preds = %1973
store double 0.000000e+00, double* %78
store i32 1, i32* %38
br label %1977
1977: ; preds = %1994, %1976
%1978 = load i32, i32* %38
%1979 = icmp sle i32 %1978, 26
br i1 %1979, label %1980, label %1997
1980: ; preds = %1977
%1981 = load i32, i32* %35
%1982 = sext i32 %1981 to i64
%1983 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %74, i64 0, i64 %1982
%1984 = load i32, i32* %38
%1985 = sext i32 %1984 to i64
%1986 = getelementptr inbounds [27 x double], [27 x double]* %1983, i64 0, i64 %1985
%1987 = load double, double* %1986
%1988 = load i32, i32* %38
%1989 = sext i32 %1988 to i64
%1990 = getelementptr inbounds [27 x double], [27 x double]* %71, i64 0, i64 %1989
%1991 = load double, double* %1990
%1992 = load double, double* %78
%1993 = call double @llvm.fmuladd.f64(double %1987, double %1991, double %1992)
store double %1993, double* %78
br label %1994
1994: ; preds = %1980
%1995 = load i32, i32* %38
%1996 = add nsw i32 %1995, 1
store i32 %1996, i32* %38
br label %1977
1997: ; preds = %1977
%1998 = load i32, i32* %35
%1999 = sext i32 %1998 to i64
%2000 = getelementptr inbounds [27 x double], [27 x double]* %70, i64 0, i64 %1999
%2001 = load double, double* %2000
%2002 = load double, double* %78
%2003 = fsub double %2001, %2002
%2004 = load i32, i32* %35
%2005 = sext i32 %2004 to i64
%2006 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %2005
store double %2003, double* %2006
br label %2007
2007: ; preds = %1997
%2008 = load i32, i32* %35
%2009 = add nsw i32 %2008, 1
store i32 %2009, i32* %35
br label %1973
2010: ; preds = %1973
store i32 2, i32* %35
br label %2011
2011: ; preds = %2042, %2010
%2012 = load i32, i32* %35
%2013 = icmp sle i32 %2012, 26
br i1 %2013, label %2014, label %2045
2014: ; preds = %2011
%2015 = load i32, i32* %35
%2016 = add nsw i32 %2015, 1
store i32 %2016, i32* %38
br label %2017
2017: ; preds = %2038, %2014
%2018 = load i32, i32* %38
%2019 = icmp sle i32 %2018, 26
br i1 %2019, label %2020, label %2041
2020: ; preds = %2017
%2021 = load i32, i32* %38
%2022 = sext i32 %2021 to i64
%2023 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %69, i64 0, i64 %2022
%2024 = load i32, i32* %35
%2025 = sext i32 %2024 to i64
%2026 = getelementptr inbounds [27 x double], [27 x double]* %2023, i64 0, i64 %2025
%2027 = load double, double* %2026
%2028 = load i32, i32* %35
%2029 = sext i32 %2028 to i64
%2030 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %2029
%2031 = load double, double* %2030
%2032 = load i32, i32* %38
%2033 = sext i32 %2032 to i64
%2034 = getelementptr inbounds [27 x double], [27 x double]* %73, i64 0, i64 %2033
%2035 = load double, double* %2034
%2036 = fneg double %2027
%2037 = call double @llvm.fmuladd.f64(double %2036, double %2031, double %2035)
store double %2037, double* %2034
br label %2038
2038: ; preds = %2020
%2039 = load i32, i32* %38
%2040 = add nsw i32 %2039, 1
store i32 %2040, i32* %38
br label %2017
2041: ; preds = %2017
br label %2042
2042: ; preds = %2041
%2043 = load i32, i32* %35
%2044 = add nsw i32 %2043, 1
store i32 %2044, i32* %35
br label %2011
2045: ; preds = %2011
br label %2055
2046: ; preds = %1967
store i32 -1, i32* %57
%2047 = load i32, i32* %57
store i32 %2047, i32* %14
br label %2095
2048: ; preds = %1954
store i32 0, i32* %80
br label %2049
2049: ; preds = %2048
br label %2051
2050: ; preds = %1948
store i32 0, i32* %80
br label %2051
2051: ; preds = %2050, %2049
br label %2052
2052: ; preds = %2051
%2053 = load i32, i32* %34
%2054 = add nsw i32 %2053, 1
store i32 %2054, i32* %34
br label %1945
2055: ; preds = %2045, %1945
br label %2057
2056: ; preds = %1940
store i32 0, i32* %80
br label %2057
2057: ; preds = %2056, %2055
br label %2058
2058: ; preds = %2057
%2059 = load i32, i32* %80
%2060 = icmp ne i32 %2059, 0
br i1 %2060, label %1872, label %2061
2061: ; preds = %2058
store i32 1, i32* %34
br label %2062
2062: ; preds = %2090, %2061
%2063 = load i32, i32* %34
%2064 = icmp sle i32 %2063, 26
br i1 %2064, label %2065, label %2093
2065: ; preds = %2062
%2066 = load i32, i32* %34
%2067 = sub nsw i32 27, %2066
%2068 = sext i32 %2067 to i64
%2069 = getelementptr inbounds [27 x double], [27 x double]* %71, i64 0, i64 %2068
%2070 = load double, double* %2069
%2071 = load i32, i32* %34
%2072 = sext i32 %2071 to i64
%2073 = getelementptr inbounds [27 x double], [27 x double]* %56, i64 0, i64 %2072
store double %2070, double* %2073
%2074 = load i32, i32* %34
%2075 = sext i32 %2074 to i64
%2076 = getelementptr inbounds [27 x double], [27 x double]* %56, i64 0, i64 %2075
%2077 = load double, double* %2076
%2078 = load double*, double** %23
%2079 = load i32, i32* %34
%2080 = sext i32 %2079 to i64
%2081 = getelementptr inbounds double, double* %2078, i64 %2080
%2082 = load double, double* %2081
%2083 = fsub double %2077, %2082
%2084 = load double, double* %22
%2085 = fdiv double %2083, %2084
%2086 = load double*, double** %25
%2087 = load i32, i32* %34
%2088 = sext i32 %2087 to i64
%2089 = getelementptr inbounds double, double* %2086, i64 %2088
store double %2085, double* %2089
br label %2090
2090: ; preds = %2065
%2091 = load i32, i32* %34
%2092 = add nsw i32 %2091, 1
store i32 %2092, i32* %34
br label %2062
2093: ; preds = %2062
%2094 = load i32, i32* %57
store i32 %2094, i32* %14
br label %2095
2095: ; preds = %2093, %2046, %1784
%2096 = load i32, i32* %14
ret i32 %2096
}

LLVM IR (-O2):
@__const.linearize.nn1 = [12 x double] [double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 2.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 1.000000e+00]
@__const.linearize.nn2 = [12 x double] [double 0.000000e+00, double 1.000000e+00, double 1.000000e+00, double 0.000000e+00, double 1.000000e+00, double 0.000000e+00, double 0.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 0.000000e+00, double 1.000000e+00]
@__const.linearize.nn6 = [12 x double] [double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 2.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 1.000000e+00, double 1.000000e+00]
define i32 @linearize(double %0, [10 x double]* nocapture %1, double* nocapture %2, double* nocapture %3, i32 %4, i32 %5, i32 %6, double %7, double* nocapture %8, double* %9, double* nocapture writeonly %10, double %11, double %12) {
%14 = alloca [12 x double]
%15 = alloca [12 x double]
%16 = alloca [12 x double]
%17 = alloca [101 x i32]
%18 = alloca [101 x i32]
%19 = alloca [101 x i32]
%20 = alloca [101 x i32]
%21 = alloca [101 x i32]
%22 = alloca [101 x i32]
%23 = alloca [101 x i32]
%24 = alloca [101 x double]
%25 = alloca [101 x double]
%26 = alloca [27 x [27 x double]]
%27 = alloca [27 x double]
%28 = alloca [27 x double]
%29 = alloca [27 x double]
%30 = alloca [27 x [27 x double]]
%31 = bitcast [12 x double]* %14 to i8*
%32 = bitcast [12 x double]* %15 to i8*
%33 = getelementptr inbounds [12 x double], [12 x double]* %15, i64 0, i64 11
store double 1.000000e+00, double* %33
%34 = bitcast [12 x double]* %16 to i8*
%35 = getelementptr inbounds [12 x double], [12 x double]* %16, i64 0, i64 2
store double 1.000000e+00, double* %35
%36 = getelementptr inbounds [12 x double], [12 x double]* %16, i64 0, i64 5
store double 1.000000e+00, double* %36
%37 = getelementptr inbounds [12 x double], [12 x double]* %16, i64 0, i64 8
store double 1.000000e+00, double* %37
%38 = getelementptr inbounds [12 x double], [12 x double]* %16, i64 0, i64 10
%39 = bitcast double* %38 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 1.000000e+00>, <2 x double>* %39
%40 = bitcast [101 x i32]* %17 to i8*
%41 = bitcast [101 x i32]* %18 to i8*
%42 = bitcast [101 x i32]* %19 to i8*
%43 = bitcast [101 x i32]* %20 to i8*
%44 = bitcast [101 x i32]* %21 to i8*
%45 = bitcast [101 x i32]* %22 to i8*
%46 = bitcast [101 x i32]* %23 to i8*
%47 = bitcast [101 x double]* %24 to i8*
%48 = bitcast [101 x double]* %25 to i8*
%49 = bitcast [27 x [27 x double]]* %26 to i8*
%50 = bitcast [27 x double]* %27 to i8*
%51 = bitcast [27 x double]* %28 to i8*
%52 = bitcast [27 x double]* %29 to i8*
%53 = bitcast [27 x [27 x double]]* %30 to i8*
br label %54
54: ; preds = %54, %13
%55 = phi i64 [ 0, %13 ], [ %137, %54 ]
%56 = or i64 %55, 1
%57 = add i64 %55, 2
%58 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 1
%59 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 1
%60 = load double, double* %58
%61 = load double, double* %59
%62 = insertelement <2 x double> poison, double %60, i64 0
%63 = insertelement <2 x double> %62, double %61, i64 1
%64 = fptosi <2 x double> %63 to <2 x i32>
%65 = getelementptr inbounds [101 x i32], [101 x i32]* %17, i64 0, i64 %56
%66 = bitcast i32* %65 to <2 x i32>*
store <2 x i32> %64, <2 x i32>* %66
%67 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 2
%68 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 2
%69 = load double, double* %67
%70 = load double, double* %68
%71 = insertelement <2 x double> poison, double %69, i64 0
%72 = insertelement <2 x double> %71, double %70, i64 1
%73 = fptosi <2 x double> %72 to <2 x i32>
%74 = getelementptr inbounds [101 x i32], [101 x i32]* %18, i64 0, i64 %56
%75 = bitcast i32* %74 to <2 x i32>*
store <2 x i32> %73, <2 x i32>* %75
%76 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 3
%77 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 3
%78 = load double, double* %76
%79 = load double, double* %77
%80 = insertelement <2 x double> poison, double %78, i64 0
%81 = insertelement <2 x double> %80, double %79, i64 1
%82 = fptosi <2 x double> %81 to <2 x i32>
%83 = getelementptr inbounds [101 x i32], [101 x i32]* %19, i64 0, i64 %56
%84 = bitcast i32* %83 to <2 x i32>*
store <2 x i32> %82, <2 x i32>* %84
%85 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 4
%86 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 4
%87 = load double, double* %85
%88 = load double, double* %86
%89 = insertelement <2 x double> poison, double %87, i64 0
%90 = insertelement <2 x double> %89, double %88, i64 1
%91 = fptosi <2 x double> %90 to <2 x i32>
%92 = getelementptr inbounds [101 x i32], [101 x i32]* %20, i64 0, i64 %56
%93 = bitcast i32* %92 to <2 x i32>*
store <2 x i32> %91, <2 x i32>* %93
%94 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 5
%95 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 5
%96 = load double, double* %94
%97 = load double, double* %95
%98 = insertelement <2 x double> poison, double %96, i64 0
%99 = insertelement <2 x double> %98, double %97, i64 1
%100 = fptosi <2 x double> %99 to <2 x i32>
%101 = getelementptr inbounds [101 x i32], [101 x i32]* %21, i64 0, i64 %56
%102 = bitcast i32* %101 to <2 x i32>*
store <2 x i32> %100, <2 x i32>* %102
%103 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 6
%104 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 6
%105 = load double, double* %103
%106 = load double, double* %104
%107 = insertelement <2 x double> poison, double %105, i64 0
%108 = insertelement <2 x double> %107, double %106, i64 1
%109 = fptosi <2 x double> %108 to <2 x i32>
%110 = getelementptr inbounds [101 x i32], [101 x i32]* %22, i64 0, i64 %56
%111 = bitcast i32* %110 to <2 x i32>*
store <2 x i32> %109, <2 x i32>* %111
%112 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 7
%113 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 7
%114 = load double, double* %112
%115 = load double, double* %113
%116 = insertelement <2 x double> poison, double %114, i64 0
%117 = insertelement <2 x double> %116, double %115, i64 1
%118 = fptosi <2 x double> %117 to <2 x i32>
%119 = getelementptr inbounds [101 x i32], [101 x i32]* %23, i64 0, i64 %56
%120 = bitcast i32* %119 to <2 x i32>*
store <2 x i32> %118, <2 x i32>* %120
%121 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 8
%122 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 8
%123 = load double, double* %121
%124 = load double, double* %122
%125 = insertelement <2 x double> poison, double %123, i64 0
%126 = insertelement <2 x double> %125, double %124, i64 1
%127 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %56
%128 = bitcast double* %127 to <2 x double>*
store <2 x double> %126, <2 x double>* %128
%129 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %56, i64 9
%130 = getelementptr inbounds [10 x double], [10 x double]* %1, i64 %57, i64 9
%131 = load double, double* %129
%132 = load double, double* %130
%133 = insertelement <2 x double> poison, double %131, i64 0
%134 = insertelement <2 x double> %133, double %132, i64 1
%135 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %56
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> %134, <2 x double>* %136
%137 = add nuw i64 %55, 2
%138 = icmp eq i64 %137, 100
br i1 %138, label %139, label %54
139: ; preds = %54
%140 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 1, i64 1
%141 = bitcast double* %140 to i8*
%142 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 2, i64 1
%143 = bitcast double* %142 to i8*
%144 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 3, i64 1
%145 = bitcast double* %144 to i8*
%146 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 4, i64 1
%147 = bitcast double* %146 to i8*
%148 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 5, i64 1
%149 = bitcast double* %148 to i8*
%150 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 6, i64 1
%151 = bitcast double* %150 to i8*
%152 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 7, i64 1
%153 = bitcast double* %152 to i8*
%154 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 8, i64 1
%155 = bitcast double* %154 to i8*
%156 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 9, i64 1
%157 = bitcast double* %156 to i8*
%158 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 10, i64 1
%159 = bitcast double* %158 to i8*
%160 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 11, i64 1
%161 = bitcast double* %160 to i8*
%162 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 12, i64 1
%163 = bitcast double* %162 to i8*
%164 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 13, i64 1
%165 = bitcast double* %164 to i8*
%166 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 14, i64 1
%167 = bitcast double* %166 to i8*
%168 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 15, i64 1
%169 = bitcast double* %168 to i8*
%170 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 16, i64 1
%171 = bitcast double* %170 to i8*
%172 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 17, i64 1
%173 = bitcast double* %172 to i8*
%174 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 18, i64 1
%175 = bitcast double* %174 to i8*
%176 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 19, i64 1
%177 = bitcast double* %176 to i8*
%178 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 20, i64 1
%179 = bitcast double* %178 to i8*
%180 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 21, i64 1
%181 = bitcast double* %180 to i8*
%182 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 22, i64 1
%183 = bitcast double* %182 to i8*
%184 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 23, i64 1
%185 = bitcast double* %184 to i8*
%186 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 24, i64 1
%187 = bitcast double* %186 to i8*
%188 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 25, i64 1
%189 = bitcast double* %188 to i8*
%190 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 26, i64 1
%191 = bitcast double* %190 to i8*
%192 = fmul double %12, %12
br label %193
193: ; preds = %139, %816
%194 = phi i64 [ 1, %139 ], [ %822, %816 ]
%195 = phi double [ 0.000000e+00, %139 ], [ %821, %816 ]
%196 = phi double [ 0.000000e+00, %139 ], [ %820, %816 ]
%197 = phi double [ 0.000000e+00, %139 ], [ %819, %816 ]
%198 = phi double [ 0.000000e+00, %139 ], [ %818, %816 ]
%199 = phi double [ 0.000000e+00, %139 ], [ %817, %816 ]
%200 = getelementptr inbounds [101 x i32], [101 x i32]* %17, i64 0, i64 %194
%201 = load i32, i32* %200
%202 = getelementptr inbounds [101 x i32], [101 x i32]* %18, i64 0, i64 %194
%203 = load i32, i32* %202
%204 = getelementptr inbounds [101 x i32], [101 x i32]* %19, i64 0, i64 %194
%205 = load i32, i32* %204
%206 = getelementptr inbounds [101 x i32], [101 x i32]* %20, i64 0, i64 %194
%207 = load i32, i32* %206
%208 = getelementptr inbounds [101 x i32], [101 x i32]* %21, i64 0, i64 %194
%209 = load i32, i32* %208
%210 = getelementptr inbounds [101 x i32], [101 x i32]* %22, i64 0, i64 %194
%211 = load i32, i32* %210
%212 = getelementptr inbounds [101 x i32], [101 x i32]* %23, i64 0, i64 %194
%213 = load i32, i32* %212
%214 = icmp slt i32 %203, 27
%215 = icmp slt i32 %213, 27
%216 = select i1 %214, i1 %215, i1 false
br i1 %216, label %217, label %816
217: ; preds = %193
%218 = sext i32 %201 to i64
%219 = getelementptr inbounds [12 x double], [12 x double]* @__const.linearize.nn1, i64 0, i64 %218
%220 = load double, double* %219
%221 = getelementptr inbounds [12 x double], [12 x double]* @__const.linearize.nn2, i64 0, i64 %218
%222 = load double, double* %221
%223 = getelementptr inbounds [12 x double], [12 x double]* %14, i64 0, i64 %218
%224 = load double, double* %223
%225 = getelementptr inbounds [12 x double], [12 x double]* %15, i64 0, i64 %218
%226 = load double, double* %225
%227 = getelementptr inbounds [12 x double], [12 x double]* %16, i64 0, i64 %218
%228 = load double, double* %227
%229 = getelementptr inbounds [12 x double], [12 x double]* @__const.linearize.nn6, i64 0, i64 %218
%230 = load double, double* %229
switch i32 %201, label %596 [
i32 0, label %231
i32 1, label %236
i32 2, label %265
i32 3, label %301
i32 4, label %311
i32 5, label %342
i32 6, label %373
i32 7, label %400
i32 8, label %433
i32 9, label %475
i32 10, label %511
i32 11, label %548
]
231: ; preds = %217
%232 = getelementptr inbounds double, double* %2, i64 %194
%233 = load double, double* %232
%234 = getelementptr inbounds double, double* %3, i64 %194
%235 = load double, double* %234
br label %596
236: ; preds = %217
%237 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%238 = load double, double* %237
%239 = fmul double %238, 9.870000e+09
%240 = tail call double @pow(double %0, double 1.500000e+00)
%241 = fmul double %239, %240
%242 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%243 = load double, double* %242
%244 = fneg double %243
%245 = fdiv double %244, %0
%246 = tail call double @exp(double %245)
%247 = fmul double %241, %246
%248 = getelementptr inbounds double, double* %2, i64 %194
%249 = load double, double* %248
%250 = fmul double %247, %249
%251 = getelementptr inbounds double, double* %3, i64 %194
store double %250, double* %251
%252 = load double, double* %248
%253 = fmul double %252, %12
store double %253, double* %248
%254 = sext i32 %205 to i64
%255 = getelementptr inbounds double, double* %9, i64 %254
%256 = load double, double* %255
%257 = fmul double %253, %256
%258 = fmul double %257, 5.000000e-01
%259 = sext i32 %203 to i64
%260 = getelementptr inbounds double, double* %9, i64 %259
%261 = load double, double* %260
%262 = fmul double %253, %261
%263 = fmul double %262, 5.000000e-01
%264 = load double, double* %251
br label %596
265: ; preds = %217
%266 = getelementptr inbounds double, double* %2, i64 %194
%267 = load double, double* %266
%268 = fmul double %267, %12
store double %268, double* %266
%269 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%270 = load double, double* %269
%271 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%272 = load double, double* %271
%273 = fneg double %272
%274 = fdiv double %273, %0
%275 = tail call double @exp(double %274)
%276 = fmul double %270, %275
%277 = load double, double* %266
%278 = fmul double %276, %277
%279 = getelementptr inbounds double, double* %3, i64 %194
store double %278, double* %279
%280 = sext i32 %205 to i64
%281 = getelementptr inbounds double, double* %9, i64 %280
%282 = load double, double* %281
%283 = load double, double* %266
%284 = fmul double %282, %283
%285 = fmul double %284, 5.000000e-01
%286 = sext i32 %203 to i64
%287 = getelementptr inbounds double, double* %9, i64 %286
%288 = load double, double* %287
%289 = fmul double %283, %288
%290 = fmul double %289, 5.000000e-01
%291 = sext i32 %213 to i64
%292 = getelementptr inbounds double, double* %9, i64 %291
%293 = load double, double* %292
%294 = fmul double %278, %293
%295 = fmul double %294, 5.000000e-01
%296 = sext i32 %211 to i64
%297 = getelementptr inbounds double, double* %9, i64 %296
%298 = load double, double* %297
%299 = fmul double %278, %298
%300 = fmul double %299, 5.000000e-01
br label %596
301: ; preds = %217
%302 = getelementptr inbounds double, double* %2, i64 %194
%303 = load double, double* %302
%304 = sext i32 %213 to i64
%305 = getelementptr inbounds double, double* %9, i64 %304
%306 = load double, double* %305
%307 = getelementptr inbounds double, double* %3, i64 %194
%308 = load double, double* %307
%309 = fmul double %306, %308
%310 = fmul double %309, 5.000000e-01
br label %596
311: ; preds = %217
%312 = getelementptr inbounds double, double* %2, i64 %194
%313 = load double, double* %312
%314 = fmul double %313, %12
store double %314, double* %312
%315 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%316 = load double, double* %315
%317 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%318 = load double, double* %317
%319 = fneg double %318
%320 = fdiv double %319, %0
%321 = tail call double @exp(double %320)
%322 = fmul double %316, %321
%323 = load double, double* %312
%324 = fmul double %322, %323
%325 = getelementptr inbounds double, double* %3, i64 %194
store double %324, double* %325
%326 = sext i32 %205 to i64
%327 = getelementptr inbounds double, double* %9, i64 %326
%328 = load double, double* %327
%329 = load double, double* %312
%330 = fmul double %328, %329
%331 = fmul double %330, 5.000000e-01
%332 = sext i32 %203 to i64
%333 = getelementptr inbounds double, double* %9, i64 %332
%334 = load double, double* %333
%335 = fmul double %329, %334
%336 = fmul double %335, 5.000000e-01
%337 = sext i32 %213 to i64
%338 = getelementptr inbounds double, double* %9, i64 %337
%339 = load double, double* %338
%340 = fmul double %324, %339
%341 = fmul double %340, 5.000000e-01
br label %596
342: ; preds = %217
%343 = getelementptr inbounds double, double* %2, i64 %194
%344 = load double, double* %343
%345 = fmul double %344, %12
store double %345, double* %343
%346 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%347 = load double, double* %346
%348 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%349 = load double, double* %348
%350 = fneg double %349
%351 = fdiv double %350, %0
%352 = tail call double @exp(double %351)
%353 = fmul double %347, %352
%354 = load double, double* %343
%355 = fmul double %353, %354
%356 = getelementptr inbounds double, double* %3, i64 %194
store double %355, double* %356
%357 = sext i32 %203 to i64
%358 = getelementptr inbounds double, double* %9, i64 %357
%359 = load double, double* %358
%360 = load double, double* %343
%361 = fmul double %359, %360
%362 = fmul double %361, 5.000000e-01
%363 = sext i32 %213 to i64
%364 = getelementptr inbounds double, double* %9, i64 %363
%365 = load double, double* %364
%366 = fmul double %355, %365
%367 = fmul double %366, 5.000000e-01
%368 = sext i32 %211 to i64
%369 = getelementptr inbounds double, double* %9, i64 %368
%370 = load double, double* %369
%371 = fmul double %355, %370
%372 = fmul double %371, 5.000000e-01
br label %596
373: ; preds = %217
%374 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%375 = load double, double* %374
%376 = fmul double %375, 9.740000e+19
%377 = tail call double @pow(double %0, double 1.500000e+00)
%378 = fmul double %376, %377
%379 = tail call double @pow(double %0, double 1.500000e+00)
%380 = fmul double %378, %379
%381 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%382 = load double, double* %381
%383 = fneg double %382
%384 = fdiv double %383, %0
%385 = tail call double @exp(double %384)
%386 = fmul double %380, %385
%387 = getelementptr inbounds double, double* %2, i64 %194
%388 = load double, double* %387
%389 = fmul double %386, %388
%390 = getelementptr inbounds double, double* %3, i64 %194
store double %389, double* %390
%391 = load double, double* %387
%392 = fmul double %192, %391
store double %392, double* %387
%393 = sext i32 %203 to i64
%394 = getelementptr inbounds double, double* %9, i64 %393
%395 = load double, double* %394
%396 = fmul double %395, %395
%397 = fmul double %392, %396
%398 = fdiv double %397, 6.000000e+00
%399 = load double, double* %390
br label %596
400: ; preds = %217
%401 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%402 = load double, double* %401
%403 = fmul double %402, 9.740000e+19
%404 = tail call double @pow(double %0, double 1.500000e+00)
%405 = fmul double %403, %404
%406 = tail call double @pow(double %0, double 1.500000e+00)
%407 = fmul double %405, %406
%408 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%409 = load double, double* %408
%410 = fneg double %409
%411 = fdiv double %410, %0
%412 = tail call double @exp(double %411)
%413 = fmul double %407, %412
%414 = getelementptr inbounds double, double* %2, i64 %194
%415 = load double, double* %414
%416 = fmul double %413, %415
%417 = getelementptr inbounds double, double* %3, i64 %194
store double %416, double* %417
%418 = load double, double* %414
%419 = fmul double %192, %418
store double %419, double* %414
%420 = sext i32 %205 to i64
%421 = getelementptr inbounds double, double* %9, i64 %420
%422 = load double, double* %421
%423 = sext i32 %203 to i64
%424 = getelementptr inbounds double, double* %9, i64 %423
%425 = load double, double* %424
%426 = fmul double %422, %425
%427 = fmul double %419, %426
%428 = fdiv double %427, 3.000000e+00
%429 = fmul double %425, %425
%430 = fmul double %419, %429
%431 = fdiv double %430, 6.000000e+00
%432 = load double, double* %417
br label %596
433: ; preds = %217
%434 = getelementptr inbounds double, double* %2, i64 %194
%435 = load double, double* %434
%436 = fmul double %435, %12
store double %436, double* %434
%437 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%438 = load double, double* %437
%439 = fmul double %438, 1.013000e-10
%440 = tail call double @pow(double %0, double -1.500000e+00)
%441 = fmul double %439, %440
%442 = fmul double %441, %12
%443 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%444 = load double, double* %443
%445 = fneg double %444
%446 = fdiv double %445, %0
%447 = tail call double @exp(double %446)
%448 = fmul double %442, %447
%449 = load double, double* %434
%450 = fmul double %448, %449
%451 = getelementptr inbounds double, double* %3, i64 %194
store double %450, double* %451
%452 = sext i32 %205 to i64
%453 = getelementptr inbounds double, double* %9, i64 %452
%454 = load double, double* %453
%455 = load double, double* %434
%456 = fmul double %454, %455
%457 = fmul double %456, 5.000000e-01
%458 = sext i32 %203 to i64
%459 = getelementptr inbounds double, double* %9, i64 %458
%460 = load double, double* %459
%461 = fmul double %455, %460
%462 = fmul double %461, 5.000000e-01
%463 = sext i32 %213 to i64
%464 = getelementptr inbounds double, double* %9, i64 %463
%465 = load double, double* %464
%466 = fmul double %465, %465
%467 = fmul double %450, %466
%468 = fdiv double %467, 6.000000e+00
%469 = sext i32 %211 to i64
%470 = getelementptr inbounds double, double* %9, i64 %469
%471 = load double, double* %470
%472 = fmul double %465, %471
%473 = fmul double %450, %472
%474 = fdiv double %473, 3.000000e+00
br label %596
475: ; preds = %217
%476 = getelementptr inbounds double, double* %2, i64 %194
%477 = load double, double* %476
%478 = fmul double %477, %12
store double %478, double* %476
%479 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%480 = load double, double* %479
%481 = fmul double %480, 1.013000e-10
%482 = tail call double @pow(double %0, double -1.500000e+00)
%483 = fmul double %481, %482
%484 = fmul double %483, %12
%485 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%486 = load double, double* %485
%487 = fneg double %486
%488 = fdiv double %487, %0
%489 = tail call double @exp(double %488)
%490 = fmul double %484, %489
%491 = load double, double* %476
%492 = fmul double %490, %491
%493 = getelementptr inbounds double, double* %3, i64 %194
store double %492, double* %493
%494 = sext i32 %205 to i64
%495 = getelementptr inbounds double, double* %9, i64 %494
%496 = load double, double* %495
%497 = load double, double* %476
%498 = fmul double %496, %497
%499 = fmul double %498, 5.000000e-01
%500 = sext i32 %203 to i64
%501 = getelementptr inbounds double, double* %9, i64 %500
%502 = load double, double* %501
%503 = fmul double %497, %502
%504 = fmul double %503, 5.000000e-01
%505 = sext i32 %213 to i64
%506 = getelementptr inbounds double, double* %9, i64 %505
%507 = load double, double* %506
%508 = fmul double %507, %507
%509 = fmul double %492, %508
%510 = fdiv double %509, 6.000000e+00
br label %596
511: ; preds = %217
%512 = getelementptr inbounds double, double* %2, i64 %194
%513 = load double, double* %512
%514 = fmul double %513, %12
store double %514, double* %512
%515 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%516 = load double, double* %515
%517 = fmul double %516, 1.013000e-10
%518 = tail call double @pow(double %0, double -1.500000e+00)
%519 = fmul double %517, %518
%520 = fmul double %519, %12
%521 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%522 = load double, double* %521
%523 = fneg double %522
%524 = fdiv double %523, %0
%525 = tail call double @exp(double %524)
%526 = fmul double %520, %525
%527 = load double, double* %512
%528 = fmul double %526, %527
%529 = getelementptr inbounds double, double* %3, i64 %194
store double %528, double* %529
%530 = sext i32 %203 to i64
%531 = getelementptr inbounds double, double* %9, i64 %530
%532 = load double, double* %531
%533 = load double, double* %512
%534 = fmul double %532, %533
%535 = fmul double %534, 5.000000e-01
%536 = sext i32 %213 to i64
%537 = getelementptr inbounds double, double* %9, i64 %536
%538 = load double, double* %537
%539 = sext i32 %211 to i64
%540 = getelementptr inbounds double, double* %9, i64 %539
%541 = load double, double* %540
%542 = fmul double %538, %541
%543 = fmul double %528, %542
%544 = fdiv double %543, 3.000000e+00
%545 = fmul double %541, %541
%546 = fmul double %528, %545
%547 = fdiv double %546, 6.000000e+00
br label %596
548: ; preds = %217
%549 = getelementptr inbounds double, double* %2, i64 %194
%550 = load double, double* %549
%551 = fmul double %550, %12
store double %551, double* %549
%552 = getelementptr inbounds [101 x double], [101 x double]* %24, i64 0, i64 %194
%553 = load double, double* %552
%554 = fmul double %553, 1.013000e-10
%555 = tail call double @pow(double %0, double -1.500000e+00)
%556 = fmul double %554, %555
%557 = fmul double %556, %12
%558 = getelementptr inbounds [101 x double], [101 x double]* %25, i64 0, i64 %194
%559 = load double, double* %558
%560 = fneg double %559
%561 = fdiv double %560, %0
%562 = tail call double @exp(double %561)
%563 = fmul double %557, %562
%564 = load double, double* %549
%565 = fmul double %563, %564
%566 = getelementptr inbounds double, double* %3, i64 %194
store double %565, double* %566
%567 = sext i32 %205 to i64
%568 = getelementptr inbounds double, double* %9, i64 %567
%569 = load double, double* %568
%570 = load double, double* %549
%571 = fmul double %569, %570
%572 = fmul double %571, 5.000000e-01
%573 = sext i32 %203 to i64
%574 = getelementptr inbounds double, double* %9, i64 %573
%575 = load double, double* %574
%576 = fmul double %570, %575
%577 = fmul double %576, 5.000000e-01
%578 = sext i32 %211 to i64
%579 = getelementptr inbounds double, double* %9, i64 %578
%580 = load double, double* %579
%581 = sext i32 %213 to i64
%582 = getelementptr inbounds double, double* %9, i64 %581
%583 = load double, double* %582
%584 = fmul double %580, %583
%585 = fmul double %565, %584
%586 = fdiv double %585, 3.000000e+00
%587 = sext i32 %209 to i64
%588 = getelementptr inbounds double, double* %9, i64 %587
%589 = load double, double* %588
%590 = fmul double %583, %589
%591 = fmul double %565, %590
%592 = fdiv double %591, 3.000000e+00
%593 = fmul double %580, %589
%594 = fmul double %565, %593
%595 = fdiv double %594, 3.000000e+00
br label %596
596: ; preds = %548, %217, %511, %475, %433, %400, %373, %342, %311, %301, %265, %236, %231
%597 = phi double [ %199, %217 ], [ %586, %548 ], [ 0.000000e+00, %511 ], [ 0.000000e+00, %475 ], [ 0.000000e+00, %433 ], [ 0.000000e+00, %400 ], [ 0.000000e+00, %373 ], [ 0.000000e+00, %342 ], [ 0.000000e+00, %311 ], [ 0.000000e+00, %301 ], [ 0.000000e+00, %265 ], [ 0.000000e+00, %236 ], [ 0.000000e+00, %231 ]
%598 = phi double [ %198, %217 ], [ %592, %548 ], [ %544, %511 ], [ 0.000000e+00, %475 ], [ %468, %433 ], [ 0.000000e+00, %400 ], [ 0.000000e+00, %373 ], [ %367, %342 ], [ 0.000000e+00, %311 ], [ 0.000000e+00, %301 ], [ %295, %265 ], [ 0.000000e+00, %236 ], [ 0.000000e+00, %231 ]
%599 = phi double [ %197, %217 ], [ %595, %548 ], [ %547, %511 ], [ %510, %475 ], [ %474, %433 ], [ %432, %400 ], [ %399, %373 ], [ %372, %342 ], [ %341, %311 ], [ %310, %301 ], [ %300, %265 ], [ %264, %236 ], [ %235, %231 ]
%600 = phi double [ %196, %217 ], [ %577, %548 ], [ 0.000000e+00, %511 ], [ %504, %475 ], [ %462, %433 ], [ %431, %400 ], [ 0.000000e+00, %373 ], [ 0.000000e+00, %342 ], [ %336, %311 ], [ 0.000000e+00, %301 ], [ %290, %265 ], [ %263, %236 ], [ 0.000000e+00, %231 ]
%601 = phi double [ %195, %217 ], [ %572, %548 ], [ %535, %511 ], [ %499, %475 ], [ %457, %433 ], [ %428, %400 ], [ %398, %373 ], [ %362, %342 ], [ %331, %311 ], [ %303, %301 ], [ %285, %265 ], [ %258, %236 ], [ %233, %231 ]
%602 = sub nsw i32 27, %203
%603 = sub nsw i32 27, %205
%604 = sub nsw i32 27, %207
%605 = sub nsw i32 27, %209
%606 = sub nsw i32 27, %211
%607 = sub nsw i32 27, %213
%608 = zext i32 %602 to i64
%609 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %608, i64 %608
%610 = load double, double* %609
%611 = tail call double @llvm.fmuladd.f64(double %220, double %601, double %610)
store double %611, double* %609
%612 = icmp sgt i32 %205, 0
br i1 %612, label %613, label %618
613: ; preds = %596
%614 = sext i32 %603 to i64
%615 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %614, i64 %608
%616 = load double, double* %615
%617 = tail call double @llvm.fmuladd.f64(double %222, double %601, double %616)
store double %617, double* %615
br label %618
618: ; preds = %613, %596
%619 = icmp sgt i32 %207, 0
br i1 %619, label %620, label %625
620: ; preds = %618
%621 = sext i32 %604 to i64
%622 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %621, i64 %608
%623 = load double, double* %622
%624 = tail call double @llvm.fmuladd.f64(double %224, double %601, double %623)
store double %624, double* %622
br label %625
625: ; preds = %620, %618
%626 = icmp sgt i32 %209, 0
br i1 %626, label %627, label %633
627: ; preds = %625
%628 = sext i32 %605 to i64
%629 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %628, i64 %608
%630 = load double, double* %629
%631 = fneg double %226
%632 = tail call double @llvm.fmuladd.f64(double %631, double %601, double %630)
store double %632, double* %629
br label %633
633: ; preds = %627, %625
%634 = icmp sgt i32 %211, 0
br i1 %634, label %635, label %641
635: ; preds = %633
%636 = sext i32 %606 to i64
%637 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %636, i64 %608
%638 = load double, double* %637
%639 = fneg double %228
%640 = tail call double @llvm.fmuladd.f64(double %639, double %601, double %638)
store double %640, double* %637
br label %641
641: ; preds = %635, %633
%642 = zext i32 %607 to i64
%643 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %642, i64 %608
%644 = load double, double* %643
%645 = fneg double %230
%646 = tail call double @llvm.fmuladd.f64(double %645, double %601, double %644)
store double %646, double* %643
br i1 %612, label %647, label %678
647: ; preds = %641
%648 = sext i32 %603 to i64
%649 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %608, i64 %648
%650 = load double, double* %649
%651 = tail call double @llvm.fmuladd.f64(double %220, double %600, double %650)
store double %651, double* %649
%652 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %648, i64 %648
%653 = load double, double* %652
%654 = tail call double @llvm.fmuladd.f64(double %222, double %600, double %653)
store double %654, double* %652
br i1 %619, label %655, label %660
655: ; preds = %647
%656 = sext i32 %604 to i64
%657 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %656, i64 %648
%658 = load double, double* %657
%659 = tail call double @llvm.fmuladd.f64(double %224, double %600, double %658)
store double %659, double* %657
br label %660
660: ; preds = %655, %647
br i1 %626, label %661, label %667
661: ; preds = %660
%662 = sext i32 %605 to i64
%663 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %662, i64 %648
%664 = load double, double* %663
%665 = fneg double %226
%666 = tail call double @llvm.fmuladd.f64(double %665, double %600, double %664)
store double %666, double* %663
br label %667
667: ; preds = %661, %660
br i1 %634, label %668, label %674
668: ; preds = %667
%669 = sext i32 %606 to i64
%670 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %669, i64 %648
%671 = load double, double* %670
%672 = fneg double %228
%673 = tail call double @llvm.fmuladd.f64(double %672, double %600, double %671)
store double %673, double* %670
br label %674
674: ; preds = %667, %668
%675 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %642, i64 %648
%676 = load double, double* %675
%677 = tail call double @llvm.fmuladd.f64(double %645, double %600, double %676)
store double %677, double* %675
br i1 %619, label %682, label %714
678: ; preds = %641
br i1 %619, label %679, label %714
679: ; preds = %678
%680 = sext i32 %604 to i64
%681 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %608, i64 %680
br label %688
682: ; preds = %674
%683 = sext i32 %604 to i64
%684 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %608, i64 %683
%685 = load double, double* %684
%686 = tail call double @llvm.fmuladd.f64(double %220, double 0.000000e+00, double %685)
store double %686, double* %684
%687 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %648, i64 %683
br label %688
688: ; preds = %679, %682
%689 = phi double* [ %681, %679 ], [ %687, %682 ]
%690 = phi double [ %220, %679 ], [ %222, %682 ]
%691 = phi i64 [ %680, %679 ], [ %683, %682 ]
%692 = load double, double* %689
%693 = tail call double @llvm.fmuladd.f64(double %690, double 0.000000e+00, double %692)
store double %693, double* %689
%694 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %691, i64 %691
%695 = load double, double* %694
%696 = tail call double @llvm.fmuladd.f64(double %224, double 0.000000e+00, double %695)
store double %696, double* %694
br i1 %626, label %697, label %703
697: ; preds = %688
%698 = sext i32 %605 to i64
%699 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %698, i64 %691
%700 = load double, double* %699
%701 = fneg double %226
%702 = tail call double @llvm.fmuladd.f64(double %701, double 0.000000e+00, double %700)
store double %702, double* %699
br label %703
703: ; preds = %697, %688
br i1 %634, label %704, label %710
704: ; preds = %703
%705 = sext i32 %606 to i64
%706 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %705, i64 %691
%707 = load double, double* %706
%708 = fneg double %228
%709 = tail call double @llvm.fmuladd.f64(double %708, double 0.000000e+00, double %707)
store double %709, double* %706
br label %710
710: ; preds = %704, %703
%711 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %642, i64 %691
%712 = load double, double* %711
%713 = tail call double @llvm.fmuladd.f64(double %645, double 0.000000e+00, double %712)
store double %713, double* %711
br label %714
714: ; preds = %678, %710, %674
br i1 %626, label %715, label %747
715: ; preds = %714
%716 = sext i32 %605 to i64
%717 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %608, i64 %716
%718 = load double, double* %717
%719 = fneg double %220
%720 = tail call double @llvm.fmuladd.f64(double %719, double %597, double %718)
store double %720, double* %717
br i1 %612, label %721, label %727
721: ; preds = %715
%722 = sext i32 %603 to i64
%723 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %722, i64 %716
%724 = load double, double* %723
%725 = fneg double %222
%726 = tail call double @llvm.fmuladd.f64(double %725, double %597, double %724)
store double %726, double* %723
br label %727
727: ; preds = %721, %715
br i1 %619, label %728, label %734
728: ; preds = %727
%729 = sext i32 %604 to i64
%730 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %729, i64 %716
%731 = load double, double* %730
%732 = fneg double %224
%733 = tail call double @llvm.fmuladd.f64(double %732, double %597, double %731)
store double %733, double* %730
br label %734
734: ; preds = %728, %727
%735 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %716, i64 %716
%736 = load double, double* %735
%737 = tail call double @llvm.fmuladd.f64(double %226, double %597, double %736)
store double %737, double* %735
br i1 %634, label %738, label %743
738: ; preds = %734
%739 = sext i32 %606 to i64
%740 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %739, i64 %716
%741 = load double, double* %740
%742 = tail call double @llvm.fmuladd.f64(double %228, double %597, double %741)
store double %742, double* %740
br label %743
743: ; preds = %738, %734
%744 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %642, i64 %716
%745 = load double, double* %744
%746 = tail call double @llvm.fmuladd.f64(double %230, double %597, double %745)
store double %746, double* %744
br label %747
747: ; preds = %743, %714
br i1 %634, label %750, label %748
748: ; preds = %747
%749 = fneg double %220
br label %782
750: ; preds = %747
%751 = sext i32 %606 to i64
%752 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %608, i64 %751
%753 = load double, double* %752
%754 = fneg double %220
%755 = tail call double @llvm.fmuladd.f64(double %754, double %598, double %753)
store double %755, double* %752
br i1 %612, label %756, label %762
756: ; preds = %750
%757 = sext i32 %603 to i64
%758 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %757, i64 %751
%759 = load double, double* %758
%760 = fneg double %222
%761 = tail call double @llvm.fmuladd.f64(double %760, double %598, double %759)
store double %761, double* %758
br label %762
762: ; preds = %756, %750
br i1 %619, label %763, label %769
763: ; preds = %762
%764 = sext i32 %604 to i64
%765 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %764, i64 %751
%766 = load double, double* %765
%767 = fneg double %224
%768 = tail call double @llvm.fmuladd.f64(double %767, double %598, double %766)
store double %768, double* %765
br label %769
769: ; preds = %763, %762
br i1 %626, label %770, label %775
770: ; preds = %769
%771 = sext i32 %605 to i64
%772 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %771, i64 %751
%773 = load double, double* %772
%774 = tail call double @llvm.fmuladd.f64(double %226, double %598, double %773)
store double %774, double* %772
br label %775
775: ; preds = %770, %769
%776 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %751, i64 %751
%777 = load double, double* %776
%778 = tail call double @llvm.fmuladd.f64(double %228, double %598, double %777)
store double %778, double* %776
%779 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %642, i64 %751
%780 = load double, double* %779
%781 = tail call double @llvm.fmuladd.f64(double %230, double %598, double %780)
store double %781, double* %779
br label %782
782: ; preds = %748, %775
%783 = phi double [ %749, %748 ], [ %754, %775 ]
%784 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %608, i64 %642
%785 = load double, double* %784
%786 = tail call double @llvm.fmuladd.f64(double %783, double %599, double %785)
store double %786, double* %784
br i1 %612, label %787, label %793
787: ; preds = %782
%788 = sext i32 %603 to i64
%789 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %788, i64 %642
%790 = load double, double* %789
%791 = fneg double %222
%792 = tail call double @llvm.fmuladd.f64(double %791, double %599, double %790)
store double %792, double* %789
br label %793
793: ; preds = %787, %782
br i1 %619, label %794, label %800
794: ; preds = %793
%795 = sext i32 %604 to i64
%796 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %795, i64 %642
%797 = load double, double* %796
%798 = fneg double %224
%799 = tail call double @llvm.fmuladd.f64(double %798, double %599, double %797)
store double %799, double* %796
br label %800
800: ; preds = %794, %793
br i1 %626, label %801, label %806
801: ; preds = %800
%802 = sext i32 %605 to i64
%803 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %802, i64 %642
%804 = load double, double* %803
%805 = tail call double @llvm.fmuladd.f64(double %226, double %599, double %804)
store double %805, double* %803
br label %806
806: ; preds = %801, %800
br i1 %634, label %807, label %812
807: ; preds = %806
%808 = sext i32 %606 to i64
%809 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %808, i64 %642
%810 = load double, double* %809
%811 = tail call double @llvm.fmuladd.f64(double %228, double %599, double %810)
store double %811, double* %809
br label %812
812: ; preds = %807, %806
%813 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %642, i64 %642
%814 = load double, double* %813
%815 = tail call double @llvm.fmuladd.f64(double %230, double %599, double %814)
store double %815, double* %813
br label %816
816: ; preds = %193, %812
%817 = phi double [ %597, %812 ], [ %199, %193 ]
%818 = phi double [ %598, %812 ], [ %198, %193 ]
%819 = phi double [ %599, %812 ], [ %197, %193 ]
%820 = phi double [ %600, %812 ], [ %196, %193 ]
%821 = phi double [ %601, %812 ], [ %195, %193 ]
%822 = add nuw nsw i64 %194, 1
%823 = icmp eq i64 %822, 101
br i1 %823, label %824, label %193
824: ; preds = %816
%825 = fmul double %11, 3.000000e+00
%826 = fmul double %825, 1.000000e-05
%827 = insertelement <2 x double> poison, double %826, i64 0
%828 = shufflevector <2 x double> %827, <2 x double> poison, <2 x i32> zeroinitializer
%829 = insertelement <2 x double> poison, double %7, i64 0
%830 = shufflevector <2 x double> %829, <2 x double> poison, <2 x i32> zeroinitializer
%831 = getelementptr inbounds double, double* %8, i64 -1
br label %832
832: ; preds = %824, %864
%833 = phi i64 [ 1, %824 ], [ %871, %864 ]
%834 = sub nuw nsw i64 27, %833
%835 = getelementptr inbounds double, double* %8, i64 %834
%836 = load double, double* %835
%837 = insertelement <2 x double> poison, double %836, i64 0
%838 = shufflevector <2 x double> %837, <2 x double> poison, <2 x i32> zeroinitializer
br label %839
839: ; preds = %839, %832
%840 = phi i64 [ 0, %832 ], [ %862, %839 ]
%841 = or i64 %840, 1
%842 = add i64 %840, 2
%843 = sub nuw nsw i64 27, %841
%844 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %841, i64 %833
%845 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %842, i64 %833
%846 = load double, double* %844
%847 = load double, double* %845
%848 = insertelement <2 x double> poison, double %846, i64 0
%849 = insertelement <2 x double> %848, double %847, i64 1
%850 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %849)
%851 = getelementptr inbounds double, double* %831, i64 %843
%852 = bitcast double* %851 to <2 x double>*
%853 = load <2 x double>, <2 x double>* %852
%854 = shufflevector <2 x double> %853, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%855 = fmul <2 x double> %828, %854
%856 = fdiv <2 x double> %855, %838
%857 = fcmp olt <2 x double> %850, %856
%858 = fmul <2 x double> %849, %830
%859 = select <2 x i1> %857, <2 x double> zeroinitializer, <2 x double> %858
%860 = extractelement <2 x double> %859, i64 0
store double %860, double* %844
%861 = extractelement <2 x double> %859, i64 1
store double %861, double* %845
%862 = add nuw i64 %840, 2
%863 = icmp eq i64 %862, 26
br i1 %863, label %864, label %839
864: ; preds = %839
%865 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %833, i64 %833
%866 = load double, double* %865
%867 = fadd double %866, 1.000000e+00
store double %867, double* %865
%868 = getelementptr inbounds double, double* %8, i64 %833
%869 = load double, double* %868
%870 = getelementptr inbounds [27 x double], [27 x double]* %27, i64 0, i64 %834
store double %869, double* %870
%871 = add nuw nsw i64 %833, 1
%872 = icmp eq i64 %871, 27
br i1 %872, label %873, label %832
873: ; preds = %864
%874 = icmp eq i32 %4, 1
%875 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 1
%876 = bitcast double* %875 to i8*
%877 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 1
%878 = bitcast double* %877 to i8*
%879 = getelementptr inbounds [27 x double], [27 x double]* %27, i64 0, i64 1
%880 = bitcast double* %879 to i8*
%881 = select i1 %874, i32 %6, i32 0
%882 = icmp eq i32 %881, %5
br i1 %882, label %883, label %899
883: ; preds = %873, %896
%884 = phi i64 [ %897, %896 ], [ 1, %873 ]
br label %885
885: ; preds = %885, %883
%886 = phi i64 [ 1, %883 ], [ %894, %885 ]
%887 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %886, i64 %884
%888 = load double, double* %887
%889 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %30, i64 0, i64 %886, i64 %884
store double %888, double* %889
%890 = add nuw nsw i64 %886, 1
%891 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %890, i64 %884
%892 = load double, double* %891
%893 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %30, i64 0, i64 %890, i64 %884
store double %892, double* %893
%894 = add nuw nsw i64 %886, 2
%895 = icmp eq i64 %894, 27
br i1 %895, label %896, label %885
896: ; preds = %885
%897 = add nuw nsw i64 %884, 1
%898 = icmp eq i64 %897, 27
br i1 %898, label %899, label %883
899: ; preds = %896, %873
br label %909
900: ; preds = %1011, %922
%901 = add nuw nsw i64 %912, 1
%902 = icmp eq i64 %923, 27
%903 = add i64 %910, 1
br i1 %902, label %904, label %909
904: ; preds = %900
%905 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 26, i64 26
%906 = load double, double* %905
%907 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 26
%908 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 26
br label %1015
909: ; preds = %899, %900
%910 = phi i64 [ %903, %900 ], [ 0, %899 ]
%911 = phi i64 [ %923, %900 ], [ 1, %899 ]
%912 = phi i64 [ %901, %900 ], [ 2, %899 ]
%913 = sub i64 25, %910
%914 = mul nuw nsw i64 %910, 28
%915 = or i64 %914, 2
%916 = add i64 %910, 3
%917 = getelementptr [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 1, i64 %915
%918 = getelementptr [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %912, i64 0
%919 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %911, i64 %911
%920 = load double, double* %919
%921 = fcmp oeq double %920, 0.000000e+00
br i1 %921, label %1229, label %922
922: ; preds = %909
%923 = add nuw nsw i64 %911, 1
%924 = icmp ult i64 %911, 26
br i1 %924, label %925, label %900
925: ; preds = %922
%926 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %911
%927 = icmp ult i64 %913, 4
%928 = and i64 %913, -4
%929 = add i64 %912, %928
%930 = icmp eq i64 %913, %928
br label %931
931: ; preds = %925, %1011
%932 = phi i64 [ 0, %925 ], [ %1014, %1011 ]
%933 = phi i64 [ %912, %925 ], [ %1012, %1011 ]
%934 = add i64 %932, 2
%935 = getelementptr [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %934, i64 %915
%936 = add i64 %916, %932
%937 = getelementptr [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %936, i64 0
%938 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %933, i64 %911
%939 = load double, double* %938
%940 = fcmp une double %939, 0.000000e+00
br i1 %940, label %941, label %1011
941: ; preds = %931
%942 = load double, double* %919
%943 = fdiv double %939, %942
%944 = fneg double %943
br i1 %927, label %976, label %945
945: ; preds = %941
%946 = icmp ult double* %935, %918
%947 = icmp ult double* %917, %937
%948 = and i1 %946, %947
br i1 %948, label %976, label %949
949: ; preds = %945
%950 = insertelement <2 x double> poison, double %944, i64 0
%951 = shufflevector <2 x double> %950, <2 x double> poison, <2 x i32> zeroinitializer
%952 = insertelement <2 x double> poison, double %944, i64 0
%953 = shufflevector <2 x double> %952, <2 x double> poison, <2 x i32> zeroinitializer
br label %954
954: ; preds = %954, %949
%955 = phi i64 [ 0, %949 ], [ %973, %954 ]
%956 = add i64 %912, %955
%957 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %911, i64 %956
%958 = bitcast double* %957 to <2 x double>*
%959 = load <2 x double>, <2 x double>* %958
%960 = getelementptr inbounds double, double* %957, i64 2
%961 = bitcast double* %960 to <2 x double>*
%962 = load <2 x double>, <2 x double>* %961
%963 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %933, i64 %956
%964 = bitcast double* %963 to <2 x double>*
%965 = load <2 x double>, <2 x double>* %964
%966 = getelementptr inbounds double, double* %963, i64 2
%967 = bitcast double* %966 to <2 x double>*
%968 = load <2 x double>, <2 x double>* %967
%969 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %951, <2 x double> %959, <2 x double> %965)
%970 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %953, <2 x double> %962, <2 x double> %968)
%971 = bitcast double* %963 to <2 x double>*
store <2 x double> %969, <2 x double>* %971
%972 = bitcast double* %966 to <2 x double>*
store <2 x double> %970, <2 x double>* %972
%973 = add nuw i64 %955, 4
%974 = icmp eq i64 %973, %928
br i1 %974, label %975, label %954
975: ; preds = %954
br i1 %930, label %1006, label %976
976: ; preds = %945, %941, %975
%977 = phi i64 [ %912, %945 ], [ %912, %941 ], [ %929, %975 ]
%978 = sub i64 1, %977
%979 = and i64 %978, 1
%980 = icmp eq i64 %979, 0
br i1 %980, label %988, label %981
981: ; preds = %976
%982 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %911, i64 %977
%983 = load double, double* %982
%984 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %933, i64 %977
%985 = load double, double* %984
%986 = tail call double @llvm.fmuladd.f64(double %944, double %983, double %985)
store double %986, double* %984
%987 = add nuw nsw i64 %977, 1
br label %988
988: ; preds = %981, %976
%989 = phi i64 [ %977, %976 ], [ %987, %981 ]
%990 = icmp eq i64 %977, 26
br i1 %990, label %1006, label %991
991: ; preds = %988, %991
%992 = phi i64 [ %1004, %991 ], [ %989, %988 ]
%993 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %911, i64 %992
%994 = load double, double* %993
%995 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %933, i64 %992
%996 = load double, double* %995
%997 = tail call double @llvm.fmuladd.f64(double %944, double %994, double %996)
store double %997, double* %995
%998 = add nuw nsw i64 %992, 1
%999 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %911, i64 %998
%1000 = load double, double* %999
%1001 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %933, i64 %998
%1002 = load double, double* %1001
%1003 = tail call double @llvm.fmuladd.f64(double %944, double %1000, double %1002)
store double %1003, double* %1001
%1004 = add nuw nsw i64 %992, 2
%1005 = icmp eq i64 %1004, 27
br i1 %1005, label %1006, label %991
1006: ; preds = %988, %991, %975
store double %943, double* %938
%1007 = load double, double* %926
%1008 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %933
%1009 = load double, double* %1008
%1010 = tail call double @llvm.fmuladd.f64(double %944, double %1007, double %1009)
store double %1010, double* %1008
br label %1011
1011: ; preds = %931, %1006
%1012 = add nuw nsw i64 %933, 1
%1013 = icmp eq i64 %1012, 27
%1014 = add i64 %932, 1
br i1 %1013, label %900, label %931
1015: ; preds = %1162, %904
%1016 = phi double [ %1163, %1162 ], [ 0.000000e+00, %904 ]
%1017 = phi i1 [ false, %1162 ], [ true, %904 ]
%1018 = load double, double* %907
%1019 = fdiv double %1018, %906
store double %1019, double* %907
%1020 = fadd double %1019, %1016
store double %1020, double* %908
br label %1021
1021: ; preds = %1072, %1015
%1022 = phi i64 [ %1085, %1072 ], [ 0, %1015 ]
%1023 = phi i64 [ %1083, %1072 ], [ 25, %1015 ]
%1024 = add i64 %1022, 1
%1025 = and i64 %1024, 3
%1026 = icmp eq i64 %1025, 0
br i1 %1026, label %1039, label %1027
1027: ; preds = %1021, %1027
%1028 = phi i64 [ %1031, %1027 ], [ %1023, %1021 ]
%1029 = phi double [ %1036, %1027 ], [ 0.000000e+00, %1021 ]
%1030 = phi i64 [ %1037, %1027 ], [ 0, %1021 ]
%1031 = add nuw nsw i64 %1028, 1
%1032 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %1023, i64 %1031
%1033 = load double, double* %1032
%1034 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1031
%1035 = load double, double* %1034
%1036 = tail call double @llvm.fmuladd.f64(double %1033, double %1035, double %1029)
%1037 = add i64 %1030, 1
%1038 = icmp eq i64 %1037, %1025
br i1 %1038, label %1039, label %1027
1039: ; preds = %1027, %1021
%1040 = phi double [ undef, %1021 ], [ %1036, %1027 ]
%1041 = phi i64 [ %1023, %1021 ], [ %1031, %1027 ]
%1042 = phi double [ 0.000000e+00, %1021 ], [ %1036, %1027 ]
%1043 = icmp ult i64 %1022, 3
br i1 %1043, label %1072, label %1044
1044: ; preds = %1039, %1044
%1045 = phi i64 [ %1065, %1044 ], [ %1041, %1039 ]
%1046 = phi double [ %1070, %1044 ], [ %1042, %1039 ]
%1047 = add nuw nsw i64 %1045, 1
%1048 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %1023, i64 %1047
%1049 = load double, double* %1048
%1050 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1047
%1051 = load double, double* %1050
%1052 = tail call double @llvm.fmuladd.f64(double %1049, double %1051, double %1046)
%1053 = add nuw nsw i64 %1045, 2
%1054 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %1023, i64 %1053
%1055 = load double, double* %1054
%1056 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1053
%1057 = load double, double* %1056
%1058 = tail call double @llvm.fmuladd.f64(double %1055, double %1057, double %1052)
%1059 = add nuw nsw i64 %1045, 3
%1060 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %1023, i64 %1059
%1061 = load double, double* %1060
%1062 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1059
%1063 = load double, double* %1062
%1064 = tail call double @llvm.fmuladd.f64(double %1061, double %1063, double %1058)
%1065 = add nuw nsw i64 %1045, 4
%1066 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %1023, i64 %1065
%1067 = load double, double* %1066
%1068 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1065
%1069 = load double, double* %1068
%1070 = tail call double @llvm.fmuladd.f64(double %1067, double %1069, double %1064)
%1071 = icmp eq i64 %1065, 26
br i1 %1071, label %1072, label %1044
1072: ; preds = %1044, %1039
%1073 = phi double [ %1040, %1039 ], [ %1070, %1044 ]
%1074 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1023
%1075 = load double, double* %1074
%1076 = fsub double %1075, %1073
%1077 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %1023, i64 %1023
%1078 = load double, double* %1077
%1079 = fdiv double %1076, %1078
store double %1079, double* %1074
%1080 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1023
%1081 = load double, double* %1080
%1082 = fadd double %1079, %1081
store double %1082, double* %1080
%1083 = add nsw i64 %1023, -1
%1084 = icmp ugt i64 %1023, 1
%1085 = add i64 %1022, 1
br i1 %1084, label %1021, label %1086
1086: ; preds = %1072
br i1 %882, label %1087, label %1164
1087: ; preds = %1086, %1158
%1088 = phi i64 [ %1159, %1158 ], [ 1, %1086 ]
%1089 = phi i1 [ true, %1158 ], [ false, %1086 ]
%1090 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1088
%1091 = load double, double* %1090
%1092 = fcmp une double %1091, 0.000000e+00
br i1 %1092, label %1093, label %1147
1093: ; preds = %1087
%1094 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1088
%1095 = load double, double* %1094
%1096 = fdiv double %1095, %1091
%1097 = tail call double @llvm.fabs.f64(double %1096)
%1098 = fcmp ogt double %1097, 2.000000e-04
br i1 %1098, label %1099, label %1147
1099: ; preds = %1152, %1093
%1100 = phi i1 [ %1089, %1093 ], [ true, %1152 ]
br i1 %1017, label %1101, label %1231
1101: ; preds = %1099, %1119
%1102 = phi i64 [ %1124, %1119 ], [ 1, %1099 ]
br label %1103
1103: ; preds = %1103, %1101
%1104 = phi i64 [ 1, %1101 ], [ %1117, %1103 ]
%1105 = phi double [ 0.000000e+00, %1101 ], [ %1116, %1103 ]
%1106 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %30, i64 0, i64 %1102, i64 %1104
%1107 = load double, double* %1106
%1108 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1104
%1109 = load double, double* %1108
%1110 = tail call double @llvm.fmuladd.f64(double %1107, double %1109, double %1105)
%1111 = add nuw nsw i64 %1104, 1
%1112 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %30, i64 0, i64 %1102, i64 %1111
%1113 = load double, double* %1112
%1114 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1111
%1115 = load double, double* %1114
%1116 = tail call double @llvm.fmuladd.f64(double %1113, double %1115, double %1110)
%1117 = add nuw nsw i64 %1104, 2
%1118 = icmp eq i64 %1117, 27
br i1 %1118, label %1119, label %1103
1119: ; preds = %1103
%1120 = getelementptr inbounds [27 x double], [27 x double]* %27, i64 0, i64 %1102
%1121 = load double, double* %1120
%1122 = fsub double %1121, %1116
%1123 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1102
store double %1122, double* %1123
%1124 = add nuw nsw i64 %1102, 1
%1125 = icmp eq i64 %1124, 27
br i1 %1125, label %1129, label %1101
1126: ; preds = %1136, %1129
%1127 = add nuw nsw i64 %1131, 1
%1128 = icmp eq i64 %1132, 27
br i1 %1128, label %1161, label %1129
1129: ; preds = %1119, %1126
%1130 = phi i64 [ %1132, %1126 ], [ 2, %1119 ]
%1131 = phi i64 [ %1127, %1126 ], [ 3, %1119 ]
%1132 = add nuw nsw i64 %1130, 1
%1133 = icmp ult i64 %1130, 26
br i1 %1133, label %1134, label %1126
1134: ; preds = %1129
%1135 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1130
br label %1136
1136: ; preds = %1134, %1136
%1137 = phi i64 [ %1131, %1134 ], [ %1145, %1136 ]
%1138 = getelementptr inbounds [27 x [27 x double]], [27 x [27 x double]]* %26, i64 0, i64 %1137, i64 %1130
%1139 = load double, double* %1138
%1140 = load double, double* %1135
%1141 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1137
%1142 = load double, double* %1141
%1143 = fneg double %1139
%1144 = tail call double @llvm.fmuladd.f64(double %1143, double %1140, double %1142)
store double %1144, double* %1141
%1145 = add nuw nsw i64 %1137, 1
%1146 = icmp eq i64 %1145, 27
br i1 %1146, label %1126, label %1136
1147: ; preds = %1087, %1093
%1148 = add nuw nsw i64 %1088, 1
%1149 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1148
%1150 = load double, double* %1149
%1151 = fcmp une double %1150, 0.000000e+00
br i1 %1151, label %1152, label %1158
1152: ; preds = %1147
%1153 = getelementptr inbounds [27 x double], [27 x double]* %29, i64 0, i64 %1148
%1154 = load double, double* %1153
%1155 = fdiv double %1154, %1150
%1156 = tail call double @llvm.fabs.f64(double %1155)
%1157 = fcmp ogt double %1156, 2.000000e-04
br i1 %1157, label %1099, label %1158
1158: ; preds = %1152, %1147
%1159 = add nuw nsw i64 %1088, 2
%1160 = icmp eq i64 %1159, 27
br i1 %1160, label %1164, label %1087
1161: ; preds = %1126
br i1 %1100, label %1164, label %1162
1162: ; preds = %1161
%1163 = load double, double* %908
br label %1015
1164: ; preds = %1161, %1086, %1158
%1165 = getelementptr double, double* %10, i64 1
%1166 = getelementptr double, double* %10, i64 27
%1167 = getelementptr double, double* %8, i64 1
%1168 = getelementptr double, double* %8, i64 27
%1169 = icmp ult double* %1165, %1168
%1170 = icmp ult double* %1167, %1166
%1171 = and i1 %1169, %1170
br i1 %1171, label %1208, label %1172
1172: ; preds = %1164
%1173 = insertelement <2 x double> poison, double %7, i64 0
%1174 = shufflevector <2 x double> %1173, <2 x double> poison, <2 x i32> zeroinitializer
br label %1175
1175: ; preds = %1192, %1172
%1176 = phi i64 [ 0, %1172 ], [ %1207, %1192 ]
%1177 = or i64 %1176, 1
%1178 = sub nuw nsw i64 27, %1177
%1179 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1178
%1180 = getelementptr inbounds double, double* %1179, i64 -1
%1181 = bitcast double* %1180 to <2 x double>*
%1182 = load <2 x double>, <2 x double>* %1181
%1183 = shufflevector <2 x double> %1182, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1184 = getelementptr inbounds double, double* %8, i64 %1177
%1185 = bitcast double* %1184 to <2 x double>*
%1186 = load <2 x double>, <2 x double>* %1185
%1187 = fsub <2 x double> %1183, %1186
%1188 = fdiv <2 x double> %1187, %1174
%1189 = getelementptr inbounds double, double* %10, i64 %1177
%1190 = bitcast double* %1189 to <2 x double>*
store <2 x double> %1188, <2 x double>* %1190
%1191 = icmp eq i64 %1176, 24
br i1 %1191, label %1231, label %1192
1192: ; preds = %1175
%1193 = or i64 %1176, 3
%1194 = sub nuw nsw i64 27, %1193
%1195 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1194
%1196 = getelementptr inbounds double, double* %1195, i64 -1
%1197 = bitcast double* %1196 to <2 x double>*
%1198 = load <2 x double>, <2 x double>* %1197
%1199 = shufflevector <2 x double> %1198, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1200 = getelementptr inbounds double, double* %8, i64 %1193
%1201 = bitcast double* %1200 to <2 x double>*
%1202 = load <2 x double>, <2 x double>* %1201
%1203 = fsub <2 x double> %1199, %1202
%1204 = fdiv <2 x double> %1203, %1174
%1205 = getelementptr inbounds double, double* %10, i64 %1193
%1206 = bitcast double* %1205 to <2 x double>*
store <2 x double> %1204, <2 x double>* %1206
%1207 = add nuw nsw i64 %1176, 4
br label %1175
1208: ; preds = %1164, %1208
%1209 = phi i64 [ %1227, %1208 ], [ 1, %1164 ]
%1210 = sub nuw nsw i64 27, %1209
%1211 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1210
%1212 = load double, double* %1211
%1213 = getelementptr inbounds double, double* %8, i64 %1209
%1214 = load double, double* %1213
%1215 = fsub double %1212, %1214
%1216 = fdiv double %1215, %7
%1217 = getelementptr inbounds double, double* %10, i64 %1209
store double %1216, double* %1217
%1218 = add nuw nsw i64 %1209, 1
%1219 = sub nsw i64 26, %1209
%1220 = getelementptr inbounds [27 x double], [27 x double]* %28, i64 0, i64 %1219
%1221 = load double, double* %1220
%1222 = getelementptr inbounds double, double* %8, i64 %1218
%1223 = load double, double* %1222
%1224 = fsub double %1221, %1223
%1225 = fdiv double %1224, %7
%1226 = getelementptr inbounds double, double* %10, i64 %1218
store double %1225, double* %1226
%1227 = add nuw nsw i64 %1209, 2
%1228 = icmp eq i64 %1227, 27
br i1 %1228, label %1231, label %1208
1229: ; preds = %909
%1230 = trunc i64 %911 to i32
br label %1231
1231: ; preds = %1099, %1175, %1208, %1229
%1232 = phi i32 [ %1230, %1229 ], [ 0, %1208 ], [ 0, %1175 ], [ -1, %1099 ]
ret i32 %1232
}