#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double const);
double exp(double const);
double fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(size_t);
double p3(double);
double p4(double);
double pow(double const, double const);
double const sin(double);
double sqrt(int);
int /*<<< orphan*/ stderr;
int bothexact(double t, double r, const double *z, int Mz, double Cp,
              double *Hreturn, double *M, double *TT, double *Ureturn,
              double *wreturn, double *Sigreturn, double *Sigc) {
  const double pi = 3.14159265358979;
  const double SperA = 31556926.0;
  const double H0 = 3000.0;
  const double L = 750000.0;
  const double Tp = 2000.0 * SperA;
  const double g = 9.81;
  const double Rgas = 8.314;
  const double rho = 910.0;
  const double k = 2.1;
  const double cpheat = 2009.0;
  const double n = 3.0;
  const double A = 3.615E-13;
  const double Q = 6.0E4;
  const double Ggeo = 0.042;
  const double ST = 1.67E-5;
  const double Tmin = 223.15;
  const double Kcond = k / (rho * cpheat);
  double power, Hconst, s, lamhat, f, goft, Ts, nusqrt, nu;
  double lamhatr, fr, Hr, mu, surfArr, Uconst, omega;
  double Sigmu, lamhatrr, frr, Hrr, Tsr, nur, mur, phi, gam;
  double I4H, divQ, Ht, nut;
  double I4, dTt, Tr, Tz, Tzz;
  double H, *U, *w, *Sig;
  int i;
  double *I3;
  I3 = (double *)malloc((size_t)Mz * sizeof(double));
  if (I3 == NULL) {
    fprintf(stderr, "\n memory allocation failed\n");
    return -9999;
  }
  U = (double *)malloc((size_t)Mz * sizeof(double));
  if (U == NULL) {
    fprintf(stderr, "\n memory allocation failed\n");
    free(I3);
    return -9999;
  }
  w = (double *)malloc((size_t)Mz * sizeof(double));
  if (w == NULL) {
    fprintf(stderr, "\n memory allocation failed\n");
    free(I3);
    free(U);
    return -9999;
  }
  Sig = (double *)malloc((size_t)Mz * sizeof(double));
  if (Sig == NULL) {
    fprintf(stderr, "\n memory allocation failed\n");
    free(I3);
    free(U);
    free(w);
    return -9999;
  }
  if ((r <= 0) || (r >= L)) {
    fprintf(stderr,
            "\nERROR bothexact(): code and derivation assume 0<r<L  !\n\n");
    free(I3);
    free(U);
    free(w);
    free(Sig);
    return 1;
  }
  power = n / (2 * n + 2);
  Hconst = H0 / pow(1 - 1 / n, power);
  s = r / L;
  lamhat =
      (1 + 1 / n) * s - (1 / n) + pow(1 - s, 1 + 1 / n) - pow(s, 1 + 1 / n);
  if ((r > 0.3 * L) && (r < 0.9 * L))
    f = pow(cos(pi * (r - 0.6 * L) / (0.6 * L)), 2.0);
  else
    f = 0.0;
  goft = Cp * sin(2.0 * pi * t / Tp);
  H = Hconst * pow(lamhat, power) + goft * f;
  Ts = Tmin + ST * r;
  nusqrt = sqrt(1 + (4.0 * H * Ggeo) / (k * Ts));
  nu = (k * Ts / (2.0 * Ggeo)) * (1 + nusqrt);
  for (i = 0; i < Mz; i++) {
    if (z[i] < H) {
      TT[i] = Ts * (nu + H) / (nu + z[i]);
    } else {
      TT[i] = Ts;
    }
  }
  lamhatr = ((1 + 1 / n) / L) * (1 - pow(1 - s, 1 / n) - pow(s, 1 / n));
  if ((r > 0.3 * L) && (r < 0.9 * L))
    fr = -(pi / (0.6 * L)) * sin(2.0 * pi * (r - 0.6 * L) / (0.6 * L));
  else
    fr = 0.0;
  Hr = Hconst * power * pow(lamhat, power - 1) * lamhatr + goft * fr;
  if (Hr > 0) {
    fprintf(stderr,
            "\nERROR bothexact(): assumes H_r negative for all 0<r<L !\n\n");
    free(I3);
    free(U);
    free(w);
    free(Sig);
    return 2;
  }
  mu = Q / (Rgas * Ts * (nu + H));
  surfArr = exp(-Q / (Rgas * Ts));
  Uconst = 2.0 * pow(rho * g, n) * A;
  omega = Uconst * pow(-Hr, n) * surfArr * pow(mu, -n - 1);
  for (i = 0; i < Mz; i++) {
    if (z[i] < H) {
      I3[i] =
          p3(mu * H) * exp(mu * H) - p3(mu * (H - z[i])) * exp(mu * (H - z[i]));
      U[i] = omega * I3[i];
    } else {
      I3[i] = p3(mu * H) * exp(mu * H) - p3(0.0);
      U[i] = omega * I3[i];
    }
  }
  for (i = 0; i < Mz; i++) {
    if (z[i] < H) {
      Sigmu = -(Q * (nu + z[i])) / (Rgas * Ts * (nu + H));
      Sig[i] = (Uconst * g / cpheat) * exp(Sigmu) *
               pow(fabs(Hr) * (H - z[i]), n + 1);
    } else {
      Sig[i] = 0.0;
    }
  }
  lamhatrr = ((1 + 1 / n) / (n * L * L)) *
             (pow(1 - s, (1 / n) - 1) - pow(s, (1 / n) - 1));
  if ((r > 0.3 * L) && (r < 0.9 * L))
    frr = -(2.0 * pi * pi / (0.36 * L * L)) *
          cos(2.0 * pi * (r - 0.6 * L) / (0.6 * L));
  else
    frr = 0.0;
  Hrr = Hconst * power * (power - 1) * pow(lamhat, power - 2.0) *
            pow(lamhatr, 2.0) +
        Hconst * power * pow(lamhat, power - 1) * lamhatrr + goft * frr;
  Tsr = ST;
  nur = (k * Tsr / (2.0 * Ggeo)) * (1 + nusqrt) +
        (1 / Ts) * (Hr * Ts - H * Tsr) / nusqrt;
  mur = (-Q / (Rgas * Ts * Ts * pow(nu + H, 2.0))) *
        (Tsr * (nu + H) + Ts * (nur + Hr));
  phi = 1 / r + n * Hrr / Hr + Q * Tsr / (Rgas * Ts * Ts) - (n + 1) * mur / mu;
  gam = pow(mu, n) * exp(mu * H) * (mur * H + mu * Hr) * pow(H, n);
  for (i = 0; i < Mz; i++) {
    I4 = p4(mu * H) * exp(mu * H) - p4(mu * (H - z[i])) * exp(mu * (H - z[i]));
    w[i] = omega * ((mur / mu - phi) * I4 / mu +
                    (phi * (H - z[i]) + Hr) * I3[i] - gam * z[i]);
  }
  I4H = p4(mu * H) * exp(mu * H) - 24.0;
  divQ = -omega * (mur / mu - phi) * I4H / mu + omega * gam * H;
  Ht = (Cp * 2.0 * pi / Tp) * cos(2.0 * pi * t / Tp) * f;
  *M = Ht + divQ;
  nut = Ht / nusqrt;
  for (i = 0; i < Mz; i++) {
    if (z[i] < H) {
      dTt = Ts * ((nut + Ht) * (nu + z[i]) - (nu + H) * nut) *
            pow(nu + z[i], -2.0);
      Tr = Tsr * (nu + H) / (nu + z[i]) +
           Ts * ((nur + Hr) * (nu + z[i]) - (nu + H) * nur) *
               pow(nu + z[i], -2.0);
      Tz = -Ts * (nu + H) * pow(nu + z[i], -2.0);
      Tzz = 2.0 * Ts * (nu + H) * pow(nu + z[i], -3.0);
      Sigc[i] = dTt + U[i] * Tr + w[i] * Tz - Kcond * Tzz - Sig[i];
    } else {
      Sigc[i] = 0.0;
    }
  }
  *Hreturn = H;
  for (i = 0; i < Mz; i++) {
    Ureturn[i] = U[i];
    wreturn[i] = w[i];
    Sigreturn[i] = Sig[i];
  }
  free(I3);
  free(U);
  free(w);
  free(Sig);
  return 0;
}


x86 assembly (clang, -O0):
<bothexact>:
push   %rbp
mov    %rsp,%rbp
sub    $0x320,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
mov    %rdi,-0x20(%rbp)
mov    %esi,-0x24(%rbp)
movsd  %xmm2,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9,-0x50(%rbp)
movsd  0x1e9b(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x1e86(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x1e71(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x1e5c(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1e47(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x1e32(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x1e1d(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x1e05(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x1ded(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x1dd5(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x1dbd(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x1da5(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x1d8d(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0x1d75(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x1d5d(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x1d45(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x1d2d(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x218(%rbp)
cmpq   $0x0,-0x218(%rbp)
jne    131e <bothexact+0x17e>
mov    0x3cdc(%rip),%rax
mov    (%rax),%edi
lea    0x1e53(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0xffffd8f1,-0x4(%rbp)
jmp    2a48 <bothexact+0x18a8>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x1f8(%rbp)
cmpq   $0x0,-0x1f8(%rbp)
jne    136d <bothexact+0x1cd>
mov    0x3c99(%rip),%rax
mov    (%rax),%edi
lea    0x1e10(%rip),%rsi
call   1050 <fprintf@plt>
mov    -0x218(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffd8f1,-0x4(%rbp)
jmp    2a48 <bothexact+0x18a8>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x200(%rbp)
cmpq   $0x0,-0x200(%rbp)
jne    13c8 <bothexact+0x228>
mov    0x3c4a(%rip),%rax
mov    (%rax),%edi
lea    0x1dc1(%rip),%rsi
call   1050 <fprintf@plt>
mov    -0x218(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffd8f1,-0x4(%rbp)
jmp    2a48 <bothexact+0x18a8>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x208(%rbp)
cmpq   $0x0,-0x208(%rbp)
jne    142f <bothexact+0x28f>
mov    0x3bef(%rip),%rax
mov    (%rax),%edi
lea    0x1d66(%rip),%rsi
call   1050 <fprintf@plt>
mov    -0x218(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x200(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffd8f1,-0x4(%rbp)
jmp    2a48 <bothexact+0x18a8>
xorps  %xmm0,%xmm0
ucomisd -0x18(%rbp),%xmm0
jae    1454 <bothexact+0x2b4>
movsd  -0x18(%rbp),%xmm0
movsd  0x1c1e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     14a5 <bothexact+0x305>
mov    0x3b85(%rip),%rax
mov    (%rax),%edi
lea    0x1d18(%rip),%rsi
call   1050 <fprintf@plt>
mov    -0x218(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x200(%rbp),%rdi
call   1030 <free@plt>
mov    -0x208(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    2a48 <bothexact+0x18a8>
movsd  0x1c03(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  0x1be3(%rip),%xmm0
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x1b9b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  0x1b7a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  0x1b86(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1b8a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  0x1b6e(%rip),%xmm0
subsd  -0xf0(%rbp),%xmm0
ff
movsd  0x1b56(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x228(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  0x1b2a(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x220(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  0x1af9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    15f4 <bothexact+0x454>
movsd  0x1b17(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    15f4 <bothexact+0x454>
movsd  -0x18(%rbp),%xmm1
movsd  0x1b0f(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x1abb(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1af7(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10a0 <cos@plt>
movsd  0x1ade(%rip),%xmm1
call   10b0 <pow@plt>
movsd  %xmm0,-0x100(%rbp)
ff
jmp    15ff <bothexact+0x45f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
movsd  0x1acc(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  0x1a3f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x238(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
call   10b0 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0x230(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  0x1972(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x195e(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  0x1a1a(%rip),%xmm1
mulsd  -0x1f0(%rbp),%xmm1
ff
movsd  0x194a(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x1966(%rip),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
divsd  %xmm0,%xmm1
movsd  0x19aa(%rip),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10c0 <sqrt@plt>
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0x1935(%rip),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
movsd  0x19b5(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x1971(%rip),%xmm1
addsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17f4 <bothexact+0x654>
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    17c3 <bothexact+0x623>
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
addsd  -0x1f0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x120(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17db <bothexact+0x63b>
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17e0 <bothexact+0x640>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1745 <bothexact+0x5a5>
movsd  0x189c(%rip),%xmm0
subsd  -0xf0(%rbp),%xmm0
ff
movsd  0x18e4(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x187c(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  0x18b8(%rip),%xmm1
call   10b0 <pow@plt>
movsd  -0x240(%rbp),%xmm1
ff
subsd  %xmm0,%xmm1
movsd  0x1897(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  0x181e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    18d1 <bothexact+0x731>
movsd  0x183c(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    18d1 <bothexact+0x731>
movsd  -0x18(%rbp),%xmm1
movsd  0x1834(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x1840(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x181c(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sin@plt>
movaps %xmm0,%xmm1
movsd  0x1838(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    18dc <bothexact+0x73c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  0x178c(%rip),%xmm2
subsd  %xmm2,%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x248(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    19b2 <bothexact+0x812>
mov    0x3678(%rip),%rax
mov    (%rax),%edi
lea    0x1845(%rip),%rsi
call   1050 <fprintf@plt>
mov    -0x218(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x200(%rbp),%rdi
call   1030 <free@plt>
mov    -0x208(%rbp),%rdi
call   1030 <free@plt>
movl   $0x2,-0x4(%rbp)
jmp    2a48 <bothexact+0x18a8>
movsd  0x1696(%rip),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0x1f0(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
movsd  0x1642(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0x165e(%rip),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
movsd  0x170e(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1080 <exp@plt>
movsd  %xmm0,-0x148(%rbp)
ff
movsd  0x16ed(%rip),%xmm0
movsd  0x160d(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x168d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x15e9(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x15ae(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x258(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mulsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  0x164a(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x250(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movl   $0x0,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1cf3 <bothexact+0xb53>
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c25 <bothexact+0xa85>
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1090 <p3@plt>
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1080 <exp@plt>
movsd  %xmm0,-0x268(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1090 <p3@plt>
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1080 <exp@plt>
movsd  -0x270(%rbp),%xmm1
ff
movsd  -0x268(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x260(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x218(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x158(%rbp),%xmm0
ff
mov    -0x218(%rbp),%rax
movslq -0x20c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x1f8(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cda <bothexact+0xb3a>
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1090 <p3@plt>
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1080 <exp@plt>
movsd  %xmm0,-0x280(%rbp)
ff
xorps  %xmm0,%xmm0
call   1090 <p3@plt>
movsd  -0x280(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x278(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x218(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x158(%rbp),%xmm0
ff
mov    -0x218(%rbp),%rax
movslq -0x20c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x1f8(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cdf <bothexact+0xb3f>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1adc <bothexact+0x93c>
movl   $0x0,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1e73 <bothexact+0xcd3>
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1e44 <bothexact+0xca4>
movsd  -0x120(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x12d2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x12df(%rip),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm2
ff
addsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0x12b7(%rip),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  0x1287(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
call   1080 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x290(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movaps 0x1360(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x1f0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x12c0(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x288(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e5a <bothexact+0xcba>
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e5f <bothexact+0xcbf>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1cfd <bothexact+0xb5d>
movsd  0x121d(%rip),%xmm0
subsd  -0xf0(%rbp),%xmm0
ff
movsd  0x1295(%rip),%xmm1
call   10b0 <pow@plt>
movsd  %xmm0,-0x298(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  0x1278(%rip),%xmm1
call   10b0 <pow@plt>
movsd  -0x298(%rbp),%xmm1
ff
subsd  %xmm0,%xmm1
movsd  0x1257(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  0x11ae(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1f41 <bothexact+0xda1>
movsd  0x11cc(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    1f41 <bothexact+0xda1>
movsd  -0x18(%rbp),%xmm1
movsd  0x11c4(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x11d0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x11ac(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10a0 <cos@plt>
movaps %xmm0,%xmm1
movsd  0x11f8(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1f4c <bothexact+0xdac>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  0x112c(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  0x112c(%rip),%xmm2
subsd  %xmm2,%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x2d0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  0x10fc(%rip),%xmm1
call   10b0 <pow@plt>
movsd  %xmm0,-0x2c0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  0x1097(%rip),%xmm2
subsd  %xmm2,%xmm1
call   10b0 <pow@plt>
movsd  -0x2c8(%rbp),%xmm1
ff
movsd  -0x2c0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x2b8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm0
mulsd  -0x168(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x170(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0xfaf(%rip),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  0xfcf(%rip),%xmm0
mulsd  -0x180(%rbp),%xmm0
ff
movsd  0x104f(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x100b(%rip),%xmm2
addsd  -0x118(%rbp),%xmm2
ff
movsd  0xffb(%rip),%xmm1
divsd  -0x110(%rbp),%xmm1
ff
movsd  -0x138(%rbp),%xmm3
ff
movsd  -0x110(%rbp),%xmm5
ff
movsd  -0x1f0(%rbp),%xmm4
ff
mulsd  -0x180(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
divsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  0xf48(%rip),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
mulsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b0(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0x1f0(%rbp),%xmm0
ff
movsd  0xf88(%rip),%xmm1
call   10b0 <pow@plt>
movsd  -0x2b0(%rbp),%xmm1
ff
mulsd  %xmm0,%xmm1
movsd  0xfbf(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm3
ff
addsd  -0x1f0(%rbp),%xmm3
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0x188(%rbp),%xmm4
ff
addsd  -0x138(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  0xef3(%rip),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  0xe7e(%rip),%xmm1
mulsd  -0x178(%rbp),%xmm1
ff
divsd  -0x138(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  0xe52(%rip),%xmm1
mulsd  -0x180(%rbp),%xmm1
ff
movsd  0xe72(%rip),%xmm2
mulsd  -0x110(%rbp),%xmm2
ff
mulsd  -0x110(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  0xeda(%rip),%xmm1
mulsd  -0x190(%rbp),%xmm1
ff
divsd  -0x140(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  0xe06(%rip),%xmm1
call   10b0 <pow@plt>
movsd  %xmm0,-0x2a8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1080 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x2a8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  -0x190(%rbp),%xmm1
ff
movsd  -0x1f0(%rbp),%xmm3
ff
movsd  -0x140(%rbp),%xmm2
ff
mulsd  -0x138(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  0xd91(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x2a0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movl   $0x0,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    248b <bothexact+0x12eb>
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1040 <p4@plt>
movsd  %xmm0,-0x2d8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,-0x2e0(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <p4@plt>
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1080 <exp@plt>
movsd  -0x2e8(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x2d8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  -0x190(%rbp),%xmm1
ff
divsd  -0x140(%rbp),%xmm1
ff
subsd  -0x198(%rbp),%xmm1
ff
mulsd  -0x1c8(%rbp),%xmm1
ff
divsd  -0x140(%rbp),%xmm1
ff
movsd  -0x198(%rbp),%xmm2
ff
movsd  -0x1f0(%rbp),%xmm4
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
movsd  -0x138(%rbp),%xmm3
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    -0x218(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x1a0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x200(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    22c5 <bothexact+0x1125>
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1040 <p4@plt>
movsd  %xmm0,-0x2f8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x1f0(%rbp),%xmm0
ff
call   1080 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x2f8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0xc5c(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
divsd  -0x140(%rbp),%xmm0
ff
subsd  -0x198(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
mulsd  -0x1a8(%rbp),%xmm1
ff
divsd  -0x140(%rbp),%xmm1
ff
movsd  -0x158(%rbp),%xmm0
ff
mulsd  -0x1a0(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  0xb65(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  0xb18(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xaec(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2f0(%rbp)
ff
movsd  0xb58(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  0xacb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   10a0 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x2f0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
addsd  -0x1b0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x1b8(%rbp),%xmm0
ff
divsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movl   $0x0,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    296b <bothexact+0x17cb>
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    293f <bothexact+0x179f>
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x1c0(%rbp),%xmm1
ff
addsd  -0x1b8(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm3
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
movsd  -0x120(%rbp),%xmm2
ff
addsd  -0x1f0(%rbp),%xmm2
ff
mulsd  -0x1c0(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xa8d(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x320(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
addsd  -0x1f0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x120(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm1
ff
addsd  -0x138(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm3
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
movsd  -0x120(%rbp),%xmm2
ff
addsd  -0x1f0(%rbp),%xmm2
ff
mulsd  -0x188(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x99e(%rip),%xmm1
call   10b0 <pow@plt>
movsd  -0x318(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x310(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x120(%rbp),%xmm1
ff
addsd  -0x1f0(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x91b(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x308(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  0x86f(%rip),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
addsd  -0x1f0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x300(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x8ab(%rip),%xmm1
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x300(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm1
ff
mov    -0x1f8(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x1d8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x200(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x1e8(%rbp),%xmm0
ff
movsd  0x829(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2952 <bothexact+0x17b2>
mov    0x20(%rbp),%rax
movslq -0x20c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2957 <bothexact+0x17b7>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    25f7 <bothexact+0x1457>
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    2a11 <bothexact+0x1871>
mov    -0x1f8(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x200(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    2985 <bothexact+0x17e5>
mov    -0x218(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x200(%rbp),%rdi
call   1030 <free@plt>
mov    -0x208(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x320,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bothexact>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,%r14
mov    %r8,%r12
mov    %rcx,0x158(%rsp)
mov    %rdx,%r15
movsd  %xmm2,0x138(%rsp)
mov    %esi,%ebx
mov    %rdi,%r13
movsd  %xmm1,0x80(%rsp)
movsd  %xmm0,0xe8(%rsp)
movslq %esi,%rbp
shl    $0x3,%rbp
mov    %rbp,%rdi
call   1070 <malloc@plt>
test   %rax,%rax
je     15e9 <bothexact+0x449>
mov    %r15,0x130(%rsp)
mov    %rax,0x48(%rsp)
mov    %ebx,0x10(%rsp)
mov    %rbp,%rdi
call   1070 <malloc@plt>
test   %rax,%rax
je     1600 <bothexact+0x460>
mov    %rax,%r15
mov    %r14,0x128(%rsp)
mov    %rbp,%rdi
call   1070 <malloc@plt>
test   %rax,%rax
je     161c <bothexact+0x47c>
mov    %rax,%r14
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,0x98(%rsp)
test   %rax,%rax
je     1640 <bothexact+0x4a0>
xorpd  %xmm0,%xmm0
movsd  0x80(%rsp),%xmm3
ucomisd %xmm3,%xmm0
jae    1686 <bothexact+0x4e6>
ucomisd 0x1d8d(%rip),%xmm3
jae    1686 <bothexact+0x4e6>
movapd %xmm3,%xmm2
divsd  0x1d7b(%rip),%xmm2
movsd  %xmm2,0x68(%rsp)
movsd  0x1d75(%rip),%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x1d6d(%rip),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x1d68(%rip),%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,0xc0(%rsp)
call   10b0 <pow@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x68(%rsp),%xmm0
movsd  0x1d2d(%rip),%xmm1
call   10b0 <pow@plt>
movsd  0x80(%rsp),%xmm2
ucomisd 0x1d2f(%rip),%xmm2
seta   %al
movsd  0x1d2c(%rip),%xmm1
ucomisd %xmm2,%xmm1
seta   %bpl
movsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
and    %al,%bpl
xorpd  %xmm0,%xmm0
cmp    $0x1,%bpl
jne    134b <bothexact+0x1ab>
movsd  0x1d07(%rip),%xmm0
addsd  0x80(%rsp),%xmm0
mulsd  0x1cfe(%rip),%xmm0
divsd  0x1cfe(%rip),%xmm0
call   10a0 <cos@plt>
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x90(%rsp)
movsd  0xe8(%rsp),%xmm0
mulsd  0x1ce3(%rip),%xmm0
divsd  0x1ce3(%rip),%xmm0
movsd  %xmm0,0xe8(%rsp)
call   1060 <sin@plt>
mulsd  0x138(%rsp),%xmm0
movsd  %xmm0,0x100(%rsp)
movsd  0x1cc3(%rip),%xmm1
movsd  0x20(%rsp),%xmm0
call   10b0 <pow@plt>
movsd  0x90(%rsp),%xmm1
mulsd  0x1caf(%rip),%xmm0
mulsd  0x100(%rsp),%xmm1
addsd  %xmm1,%xmm0
movsd  0x1ca2(%rip),%xmm2
mulsd  0x80(%rsp),%xmm2
addsd  0x1c99(%rip),%xmm2
movsd  0x1c99(%rip),%xmm1
movsd  %xmm0,(%rsp)
mulsd  %xmm0,%xmm1
mulsd  0x1c90(%rip),%xmm1
movsd  0x1c90(%rip),%xmm0
movapd %xmm2,0xd0(%rsp)
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x18(%rsp)
divsd  %xmm0,%xmm1
movsd  0x1c01(%rip),%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
call   10c0 <sqrt@plt>
movsd  0x18(%rsp),%xmm1
divsd  0x1c5e(%rip),%xmm1
movsd  %xmm0,0x120(%rsp)
addsd  0x1bd5(%rip),%xmm0
movsd  %xmm0,0x78(%rsp)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
mov    0x10(%rsp),%eax
mov    %eax,%ebx
test   %eax,%eax
jle    14ba <bothexact+0x31a>
movsd  (%rsp),%xmm3
movapd %xmm3,%xmm0
addsd  0x18(%rsp),%xmm0
movapd 0xd0(%rsp),%xmm4
mulsd  %xmm4,%xmm0
cmpl   $0x1,0x10(%rsp)
jne    18a3 <bothexact+0x703>
xor    %eax,%eax
test   $0x1,%bl
je     14ba <bothexact+0x31a>
movsd  0x0(%r13,%rax,8),%xmm1
movsd  (%rsp),%xmm2
ucomisd %xmm1,%xmm2
movapd 0xd0(%rsp),%xmm2
jbe    14b4 <bothexact+0x314>
addsd  0x18(%rsp),%xmm1
divsd  %xmm1,%xmm0
movapd %xmm0,%xmm2
movsd  %xmm2,(%r12,%rax,8)
movsd  0x1bd6(%rip),%xmm1
movsd  0xc0(%rsp),%xmm0
call   10b0 <pow@plt>
movsd  0x1b40(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0xf0(%rsp)
movsd  0x68(%rsp),%xmm0
movsd  0x1ba5(%rip),%xmm1
call   10b0 <pow@plt>
movsd  0xf0(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x1b93(%rip),%xmm1
movsd  %xmm1,0xf0(%rsp)
xorpd  %xmm0,%xmm0
test   %bpl,%bpl
je     154d <bothexact+0x3ad>
movsd  0x1b09(%rip),%xmm0
addsd  0x80(%rsp),%xmm0
mulsd  0x1b10(%rip),%xmm0
divsd  0x1b00(%rip),%xmm0
call   1060 <sin@plt>
mulsd  0x1b5b(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b55(%rip),%xmm1
movsd  0x20(%rsp),%xmm0
call   10b0 <pow@plt>
movapd %xmm0,%xmm1
mulsd  0x1b46(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  0x100(%rsp),%xmm2
movsd  0xf0(%rsp),%xmm0
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
ucomisd 0x1bbe(%rip),%xmm1
mov    0x98(%rsp),%r12
jbe    16c9 <bothexact+0x529>
mov    0x3a31(%rip),%rax
mov    (%rax),%edi
lea    0x1c1e(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    $0x2,%eax
jmp    1674 <bothexact+0x4d4>
mov    0x39f0(%rip),%rax
mov    (%rax),%edi
lea    0x1b87(%rip),%rsi
call   1050 <fprintf@plt>
jmp    166f <bothexact+0x4cf>
mov    0x39d9(%rip),%rax
mov    (%rax),%edi
lea    0x1b70(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x48(%rsp),%rdi
jmp    166a <bothexact+0x4ca>
mov    0x39bd(%rip),%rax
mov    (%rax),%edi
lea    0x1b54(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
jmp    166a <bothexact+0x4ca>
mov    0x3999(%rip),%rax
mov    (%rax),%edi
lea    0x1b30(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    $0xffffd8f1,%eax
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x3953(%rip),%rax
mov    (%rax),%edi
lea    0x1b06(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
jmp    1674 <bothexact+0x4d4>
mov    %bpl,0x17(%rsp)
movsd  0x19ea(%rip),%xmm2
mulsd  0xd0(%rsp),%xmm2
movsd  (%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movapd %xmm2,%xmm3
movapd %xmm0,0x160(%rsp)
mulsd  %xmm0,%xmm3
movsd  0x19c5(%rip),%xmm0
movsd  %xmm3,0x70(%rsp)
divsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x19b5(%rip),%xmm0
movsd  %xmm2,0x150(%rsp)
divsd  %xmm2,%xmm0
movapd %xmm1,0x140(%rsp)
call   1080 <exp@plt>
movsd  %xmm0,0x30(%rsp)
movaps 0x1a1d(%rip),%xmm0
xorps  0x140(%rsp),%xmm0
movsd  0x1985(%rip),%xmm1
call   10b0 <pow@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x197a(%rip),%xmm1
movsd  0x8(%rsp),%xmm0
call   10b0 <pow@plt>
movsd  (%rsp),%xmm1
movsd  0x28(%rsp),%xmm2
mulsd  0x1964(%rip),%xmm2
mulsd  0x30(%rsp),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x28(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    19b7 <bothexact+0x817>
mulsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x30(%rsp)
xor    %ebp,%ebp
jmp    1806 <bothexact+0x666>
nop
xorpd  %xmm0,%xmm0
call   1090 <p3@plt>
movsd  0xa0(%rsp),%xmm2
movapd %xmm0,%xmm3
xorpd  0x1992(%rip),%xmm3
movsd  0x28(%rsp),%xmm0
movsd  0xb0(%rsp),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm0
mov    0x48(%rsp),%rax
movsd  %xmm1,(%rax,%rbp,8)
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
je     190a <bothexact+0x76a>
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  0x30(%rsp),%xmm0
call   1090 <p3@plt>
movsd  %xmm0,0xb0(%rsp)
movsd  0x30(%rsp),%xmm0
call   1080 <exp@plt>
movapd %xmm0,%xmm2
movsd  (%rsp),%xmm1
ucomisd 0x50(%rsp),%xmm1
movsd  %xmm0,0xa0(%rsp)
jbe    17b0 <bothexact+0x610>
movapd %xmm1,%xmm0
subsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1090 <p3@plt>
movapd %xmm0,0x50(%rsp)
movsd  (%rsp),%xmm0
subsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1080 <exp@plt>
movapd 0x50(%rsp),%xmm3
movsd  0xa0(%rsp),%xmm2
xorpd  0x18c6(%rip),%xmm3
mulsd  %xmm0,%xmm3
jmp    17ce <bothexact+0x62e>
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
jmp    18c4 <bothexact+0x724>
nopl   0x0(%rax)
movsd  %xmm2,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
je     1486 <bothexact+0x2e6>
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm1,%xmm3
movapd %xmm4,%xmm2
jbe    18e3 <bothexact+0x743>
addsd  0x18(%rsp),%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
ucomisd %xmm1,%xmm3
movapd %xmm4,%xmm2
jbe    18b0 <bothexact+0x710>
addsd  0x18(%rsp),%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
jmp    18b0 <bothexact+0x710>
cmpl   $0x0,0x10(%rsp)
movsd  (%rsp),%xmm2
jle    19b7 <bothexact+0x817>
movapd 0x184e(%rip),%xmm0
andpd  0x140(%rsp),%xmm0
movapd %xmm0,0x50(%rsp)
xor    %ebp,%ebp
jmp    194f <bothexact+0x7af>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm1,(%r12,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
je     19b7 <bothexact+0x817>
movsd  0x0(%r13,%rbp,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm2
jbe    1940 <bothexact+0x7a0>
addsd  0x18(%rsp),%xmm0
mulsd  0x1762(%rip),%xmm0
divsd  0x70(%rsp),%xmm0
call   1080 <exp@plt>
mulsd  0x176f(%rip),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  (%rsp),%xmm0
subsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x50(%rsp),%xmm0
movsd  0x16d7(%rip),%xmm1
call   10b0 <pow@plt>
movsd  (%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  0x30(%rsp),%xmm1
jmp    1940 <bothexact+0x7a0>
mov    %rbx,0x118(%rsp)
mov    %r14,0xe0(%rsp)
movsd  0x1729(%rip),%xmm1
movsd  0xc0(%rsp),%xmm0
call   10b0 <pow@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x68(%rsp),%xmm0
movsd  0x1707(%rip),%xmm1
call   10b0 <pow@plt>
movsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x16f8(%rip),%xmm1
movsd  %xmm1,0x50(%rsp)
xorpd  %xmm0,%xmm0
cmpb   $0x0,0x17(%rsp)
je     1a47 <bothexact+0x8a7>
movsd  0x160f(%rip),%xmm0
addsd  0x80(%rsp),%xmm0
mulsd  0x1616(%rip),%xmm0
divsd  0x1606(%rip),%xmm0
call   10a0 <cos@plt>
mulsd  0x16c1(%rip),%xmm0
movsd  %xmm0,0x68(%rsp)
mov    %r15,0x70(%rsp)
movsd  0x16b6(%rip),%xmm1
movsd  0x20(%rsp),%xmm0
call   10b0 <pow@plt>
movsd  %xmm0,0xc0(%rsp)
movsd  0x163a(%rip),%xmm1
movsd  0x20(%rsp),%xmm0
call   10b0 <pow@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rsp),%xmm0
movsd  0x1643(%rip),%xmm1
call   10b0 <pow@plt>
movsd  %xmm0,0xb0(%rsp)
movsd  (%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
call   1080 <exp@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  (%rsp),%xmm0
movsd  0x1609(%rip),%xmm1
call   10b0 <pow@plt>
movsd  0xc0(%rsp),%xmm2
mulsd  0x1633(%rip),%xmm2
movsd  0xf0(%rsp),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm2,%xmm1
movsd  0x20(%rsp),%xmm3
mulsd  0x15b4(%rip),%xmm3
movsd  0x50(%rsp),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x100(%rsp),%xmm6
mulsd  0x68(%rsp),%xmm6
addsd  %xmm2,%xmm6
movsd  0x14ea(%rip),%xmm9
movapd %xmm9,%xmm1
movapd 0xd0(%rsp),%xmm4
divsd  %xmm4,%xmm1
movsd  0x15d8(%rip),%xmm2
movsd  (%rsp),%xmm10
mulsd  %xmm10,%xmm2
movapd 0x140(%rsp),%xmm8
movapd %xmm8,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
movsd  0x78(%rsp),%xmm2
mulsd  0x15ac(%rip),%xmm2
divsd  0x120(%rsp),%xmm3
addsd  %xmm3,%xmm2
movsd  0x150(%rsp),%xmm7
mulsd  %xmm4,%xmm7
movapd 0x160(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm7,%xmm1
movsd  0x151d(%rip),%xmm5
divsd  %xmm1,%xmm5
movapd %xmm8,%xmm1
movsd  %xmm2,0x78(%rsp)
addsd  %xmm2,%xmm1
movapd %xmm1,0x100(%rsp)
mulsd  %xmm1,%xmm4
movsd  0x148d(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,0x68(%rsp)
addsd  %xmm1,%xmm4
mulsd  %xmm5,%xmm4
divsd  0x80(%rsp),%xmm9
mulsd  0x14d9(%rip),%xmm6
divsd  %xmm8,%xmm6
addsd  %xmm9,%xmm6
movsd  0x151f(%rip),%xmm1
divsd  %xmm7,%xmm1
addsd  %xmm6,%xmm1
movsd  0x14bf(%rip),%xmm5
mulsd  %xmm4,%xmm5
movsd  0x8(%rsp),%xmm2
divsd  %xmm2,%xmm5
addsd  %xmm1,%xmm5
movsd  0xa0(%rsp),%xmm7
mulsd  0xb0(%rsp),%xmm7
movapd %xmm2,%xmm1
movapd %xmm2,%xmm3
mulsd  %xmm8,%xmm1
movapd %xmm4,%xmm2
movapd %xmm10,%xmm6
mulsd  %xmm10,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm7,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm2,0xc0(%rsp)
divsd  %xmm3,%xmm4
subsd  %xmm5,%xmm4
movapd %xmm4,0x80(%rsp)
cmpl   $0x0,0x10(%rsp)
mov    0x48(%rsp),%r15
mov    0xe0(%rsp),%r14
mov    0x118(%rsp),%rbx
jle    1dae <bothexact+0xc0e>
movapd 0x14b2(%rip),%xmm0
xorpd  0xc0(%rsp),%xmm0
movapd %xmm0,0xf0(%rsp)
xor    %ebp,%ebp
movsd  %xmm5,0x20(%rsp)
nopl   0x0(%rax,%rax,1)
movsd  0x30(%rsp),%xmm0
call   1040 <p4@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x30(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0xb0(%rsp)
movsd  (%rsp),%xmm0
subsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1040 <p4@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  (%rsp),%xmm0
subsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1080 <exp@plt>
movsd  0x20(%rsp),%xmm5
mulsd  0xa0(%rsp),%xmm0
movsd  0xb0(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x80(%rsp),%xmm1
movapd %xmm1,%xmm2
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm5,%xmm1
addsd  0x140(%rsp),%xmm1
mulsd  (%r15,%rbp,8),%xmm1
divsd  0x8(%rsp),%xmm2
addsd  %xmm2,%xmm1
mulsd  0xf0(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  0x28(%rsp),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1cd0 <bothexact+0xb30>
movsd  0x30(%rsp),%xmm0
call   1040 <p4@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x30(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0xe8(%rsp),%xmm0
call   10a0 <cos@plt>
movsd  0x30(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
addsd  0x1346(%rip),%xmm1
movapd %xmm1,%xmm3
movapd 0x80(%rsp),%xmm2
movsd  0x28(%rsp),%xmm1
mulsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm2
divsd  0x8(%rsp),%xmm2
movapd 0xc0(%rsp),%xmm4
mulsd  %xmm1,%xmm4
movsd  (%rsp),%xmm3
mulsd  %xmm3,%xmm4
movsd  0x138(%rsp),%xmm1
addsd  %xmm1,%xmm1
mulsd  0x11fa(%rip),%xmm1
subsd  %xmm2,%xmm4
divsd  0x1206(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x90(%rsp),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm4
mov    0x158(%rsp),%rax
movsd  %xmm4,(%rax)
cmpl   $0x0,0x10(%rsp)
jle    20bd <bothexact+0xf1d>
mov    0xe0(%rsp),%rbp
mov    0x1c0(%rsp),%r12
movapd %xmm2,%xmm1
divsd  0x120(%rsp),%xmm1
addsd  %xmm1,%xmm2
movapd 0x12c1(%rip),%xmm6
movapd 0x160(%rsp),%xmm5
movapd %xmm5,%xmm0
xorpd  %xmm6,%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
movsd  0x78(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x78(%rsp)
movapd 0xd0(%rsp),%xmm4
xorpd  %xmm4,%xmm6
mulsd  %xmm5,%xmm6
movapd %xmm6,0xb0(%rsp)
movapd %xmm4,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm0,0xa0(%rsp)
xor    %r15d,%r15d
mov    0x118(%rsp),%r14
movsd  %xmm2,0x90(%rsp)
jmp    1f23 <bothexact+0xd83>
nop
movsd  %xmm0,(%r12,%r15,8)
add    $0x1,%r15
cmp    %r15,%r14
je     2077 <bothexact+0xed7>
movsd  0x0(%r13,%r15,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm3
jbe    1f10 <bothexact+0xd70>
addsd  0x18(%rsp),%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x50(%rsp),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%rsp)
movapd %xmm1,%xmm0
movsd  0x11e2(%rip),%xmm1
call   10b0 <pow@plt>
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x0(%r13,%r15,8),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  0x68(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
movapd 0x100(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x78(%rsp),%xmm1
mulsd  0xd0(%rsp),%xmm1
movapd %xmm1,0x30(%rsp)
movsd  0x118a(%rip),%xmm1
call   10b0 <pow@plt>
mulsd  0x30(%rsp),%xmm0
addsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x0(%r13,%r15,8),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  0x115e(%rip),%xmm1
call   10b0 <pow@plt>
mulsd  0xb0(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x0(%r13,%r15,8),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  0x113d(%rip),%xmm1
call   10b0 <pow@plt>
movapd 0xd0(%rsp),%xmm4
movsd  (%rsp),%xmm3
movsd  0x90(%rsp),%xmm2
mulsd  0xa0(%rsp),%xmm0
mov    0x70(%rsp),%rax
movsd  0x28(%rsp),%xmm1
mulsd  (%rax,%r15,8),%xmm1
addsd  0x8(%rsp),%xmm1
movsd  0x30(%rsp),%xmm5
mulsd  0x0(%rbp,%r15,8),%xmm5
addsd  %xmm1,%xmm5
mulsd  0x10f0(%rip),%xmm0
addsd  %xmm5,%xmm0
mov    0x98(%rsp),%rax
subsd  (%rax,%r15,8),%xmm0
jmp    1f10 <bothexact+0xd70>
mov    0x130(%rsp),%rax
movsd  %xmm3,(%rax)
mov    0x10(%rsp),%eax
test   %eax,%eax
mov    0x70(%rsp),%rbx
mov    0x98(%rsp),%r12
mov    0x48(%rsp),%r15
mov    0x1b8(%rsp),%rsi
mov    0x1b0(%rsp),%rdi
jle    216c <bothexact+0xfcc>
cmp    $0x1,%eax
jne    20db <bothexact+0xf3b>
xor    %eax,%eax
jmp    213e <bothexact+0xf9e>
mov    0x130(%rsp),%rax
movsd  %xmm3,(%rax)
mov    0x70(%rsp),%rbx
mov    0xe0(%rsp),%rbp
jmp    216c <bothexact+0xfcc>
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x128(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    20f0 <bothexact+0xf50>
test   $0x1,%r14b
je     216c <bothexact+0xfcc>
movsd  (%rbx,%rax,8),%xmm0
mov    0x128(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
xor    %eax,%eax
jmp    1674 <bothexact+0x4d4>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [28 x i8] c"\0A memory allocation failed\0A\00"
@.str.1 = [58 x i8] c"\0AERROR bothexact(): code and derivation assume 0<r<L !\0A\0A\00"
@.str.2 = [59 x i8] c"\0AERROR bothexact(): assumes H_r negative for all 0<r<L !\0A\0A\00"
define i32 @bothexact(double %0, double %1, double* %2, i32 %3, double %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11) {
%13 = alloca i32
%14 = alloca double
%15 = alloca double
%16 = alloca double*
%17 = alloca i32
%18 = alloca double
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%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 double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double*
%79 = alloca double*
%80 = alloca double*
%81 = alloca i32
%82 = alloca double*
store double %0, double* %14
store double %1, double* %15
store double* %2, double** %16
store i32 %3, i32* %17
store double %4, double* %18
store double* %5, double** %19
store double* %6, double** %20
store double* %7, double** %21
store double* %8, double** %22
store double* %9, double** %23
store double* %10, double** %24
store double* %11, double** %25
store double 0x400921FB54442D11, double* %26
store double 0x417E1853E0000000, double* %27
store double 3.000000e+03, double* %28
store double 7.500000e+05, double* %29
store double 0x422D63C1E8C00000, double* %30
store double 9.810000e+00, double* %31
store double 8.314000e+00, double* %32
store double 9.100000e+02, double* %33
store double 2.100000e+00, double* %34
store double 2.009000e+03, double* %35
store double 3.000000e+00, double* %36
store double 3.615000e-13, double* %37
store double 6.000000e+04, double* %38
store double 4.200000e-02, double* %39
store double 1.670000e-05, double* %40
store double 2.231500e+02, double* %41
store double 0x3EB34587D5E72893, double* %42
%83 = load i32, i32* %17
%84 = sext i32 %83 to i64
%85 = mul i64 %84, 8
%86 = call i64 @malloc(i64 %85)
%87 = inttoptr i64 %86 to double*
store double* %87, double** %82
%88 = load double*, double** %82
%89 = icmp eq double* %88, null
br i1 %89, label %90, label %93
90: ; preds = %12
%91 = load i32, i32* @stderr
%92 = call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
store i32 -9999, i32* %13
br label %923
93: ; preds = %12
%94 = load i32, i32* %17
%95 = sext i32 %94 to i64
%96 = mul i64 %95, 8
%97 = call i64 @malloc(i64 %96)
%98 = inttoptr i64 %97 to double*
store double* %98, double** %78
%99 = load double*, double** %78
%100 = icmp eq double* %99, null
br i1 %100, label %101, label %106
101: ; preds = %93
%102 = load i32, i32* @stderr
%103 = call i32 @fprintf(i32 %102, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%104 = load double*, double** %82
%105 = call i32 @free(double* %104)
store i32 -9999, i32* %13
br label %923
106: ; preds = %93
%107 = load i32, i32* %17
%108 = sext i32 %107 to i64
%109 = mul i64 %108, 8
%110 = call i64 @malloc(i64 %109)
%111 = inttoptr i64 %110 to double*
store double* %111, double** %79
%112 = load double*, double** %79
%113 = icmp eq double* %112, null
br i1 %113, label %114, label %121
114: ; preds = %106
%115 = load i32, i32* @stderr
%116 = call i32 @fprintf(i32 %115, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%117 = load double*, double** %82
%118 = call i32 @free(double* %117)
%119 = load double*, double** %78
%120 = call i32 @free(double* %119)
store i32 -9999, i32* %13
br label %923
121: ; preds = %106
%122 = load i32, i32* %17
%123 = sext i32 %122 to i64
%124 = mul i64 %123, 8
%125 = call i64 @malloc(i64 %124)
%126 = inttoptr i64 %125 to double*
store double* %126, double** %80
%127 = load double*, double** %80
%128 = icmp eq double* %127, null
br i1 %128, label %129, label %138
129: ; preds = %121
%130 = load i32, i32* @stderr
%131 = call i32 @fprintf(i32 %130, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%132 = load double*, double** %82
%133 = call i32 @free(double* %132)
%134 = load double*, double** %78
%135 = call i32 @free(double* %134)
%136 = load double*, double** %79
%137 = call i32 @free(double* %136)
store i32 -9999, i32* %13
br label %923
138: ; preds = %121
%139 = load double, double* %15
%140 = fcmp ole double %139, 0.000000e+00
br i1 %140, label %144, label %141
141: ; preds = %138
%142 = load double, double* %15
%143 = fcmp oge double %142, 7.500000e+05
br i1 %143, label %144, label %155
144: ; preds = %141, %138
%145 = load i32, i32* @stderr
%146 = call i32 @fprintf(i32 %145, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.1, i64 0, i64 0))
%147 = load double*, double** %82
%148 = call i32 @free(double* %147)
%149 = load double*, double** %78
%150 = call i32 @free(double* %149)
%151 = load double*, double** %79
%152 = call i32 @free(double* %151)
%153 = load double*, double** %80
%154 = call i32 @free(double* %153)
store i32 1, i32* %13
br label %923
155: ; preds = %141
store double 3.750000e-01, double* %43
%156 = load double, double* %43
%157 = call double @pow(double 0x3FE5555555555556, double %156)
%158 = fdiv double 3.000000e+03, %157
store double %158, double* %44
%159 = load double, double* %15
%160 = fdiv double %159, 7.500000e+05
store double %160, double* %45
%161 = load double, double* %45
%162 = call double @llvm.fmuladd.f64(double 0x3FF5555555555555, double %161, double 0xBFD5555555555555)
%163 = load double, double* %45
%164 = fsub double 1.000000e+00, %163
%165 = call double @pow(double %164, double 0x3FF5555555555555)
%166 = fadd double %162, %165
%167 = load double, double* %45
%168 = call double @pow(double %167, double 0x3FF5555555555555)
%169 = fsub double %166, %168
store double %169, double* %46
%170 = load double, double* %15
%171 = fcmp ogt double %170, 2.250000e+05
br i1 %171, label %172, label %182
172: ; preds = %155
%173 = load double, double* %15
%174 = fcmp olt double %173, 6.750000e+05
br i1 %174, label %175, label %182
175: ; preds = %172
%176 = load double, double* %15
%177 = fsub double %176, 4.500000e+05
%178 = fmul double 0x400921FB54442D11, %177
%179 = fdiv double %178, 4.500000e+05
%180 = call double @cos(double %179)
%181 = call double @pow(double %180, double 2.000000e+00)
store double %181, double* %47
br label %183
182: ; preds = %172, %155
store double 0.000000e+00, double* %47
br label %183
183: ; preds = %182, %175
%184 = load double, double* %18
%185 = load double, double* %14
%186 = fmul double 0x401921FB54442D11, %185
%187 = fdiv double %186, 0x422D63C1E8C00000
%188 = call double @sin(double %187)
%189 = fmul double %184, %188
store double %189, double* %48
%190 = load double, double* %44
%191 = load double, double* %46
%192 = load double, double* %43
%193 = call double @pow(double %191, double %192)
%194 = load double, double* %48
%195 = load double, double* %47
%196 = fmul double %194, %195
%197 = call double @llvm.fmuladd.f64(double %190, double %193, double %196)
store double %197, double* %77
%198 = load double, double* %15
%199 = call double @llvm.fmuladd.f64(double 1.670000e-05, double %198, double 2.231500e+02)
store double %199, double* %49
%200 = load double, double* %77
%201 = fmul double 4.000000e+00, %200
%202 = fmul double %201, 4.200000e-02
%203 = load double, double* %49
%204 = fmul double 2.100000e+00, %203
%205 = fdiv double %202, %204
%206 = fadd double 1.000000e+00, %205
%207 = fptosi double %206 to i32
%208 = call double @sqrt(i32 %207)
store double %208, double* %50
%209 = load double, double* %49
%210 = fmul double 2.100000e+00, %209
%211 = fdiv double %210, 8.400000e-02
%212 = load double, double* %50
%213 = fadd double 1.000000e+00, %212
%214 = fmul double %211, %213
store double %214, double* %51
store i32 0, i32* %81
br label %215
215: ; preds = %252, %183
%216 = load i32, i32* %81
%217 = load i32, i32* %17
%218 = icmp slt i32 %216, %217
br i1 %218, label %219, label %255
219: ; preds = %215
%220 = load double*, double** %16
%221 = load i32, i32* %81
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %220, i64 %222
%224 = load double, double* %223
%225 = load double, double* %77
%226 = fcmp olt double %224, %225
br i1 %226, label %227, label %245
227: ; preds = %219
%228 = load double, double* %49
%229 = load double, double* %51
%230 = load double, double* %77
%231 = fadd double %229, %230
%232 = fmul double %228, %231
%233 = load double, double* %51
%234 = load double*, double** %16
%235 = load i32, i32* %81
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds double, double* %234, i64 %236
%238 = load double, double* %237
%239 = fadd double %233, %238
%240 = fdiv double %232, %239
%241 = load double*, double** %21
%242 = load i32, i32* %81
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double, double* %241, i64 %243
store double %240, double* %244
br label %251
245: ; preds = %219
%246 = load double, double* %49
%247 = load double*, double** %21
%248 = load i32, i32* %81
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %247, i64 %249
store double %246, double* %250
br label %251
251: ; preds = %245, %227
br label %252
252: ; preds = %251
%253 = load i32, i32* %81
%254 = add nsw i32 %253, 1
store i32 %254, i32* %81
br label %215
255: ; preds = %215
%256 = load double, double* %45
%257 = fsub double 1.000000e+00, %256
%258 = call double @pow(double %257, double 0x3FD5555555555555)
%259 = fsub double 1.000000e+00, %258
%260 = load double, double* %45
%261 = call double @pow(double %260, double 0x3FD5555555555555)
%262 = fsub double %259, %261
%263 = fmul double 0x3EBDD37F5698C2C2, %262
store double %263, double* %52
%264 = load double, double* %15
%265 = fcmp ogt double %264, 2.250000e+05
br i1 %265, label %266, label %276
266: ; preds = %255
%267 = load double, double* %15
%268 = fcmp olt double %267, 6.750000e+05
br i1 %268, label %269, label %276
269: ; preds = %266
%270 = load double, double* %15
%271 = fsub double %270, 4.500000e+05
%272 = fmul double 0x401921FB54442D11, %271
%273 = fdiv double %272, 4.500000e+05
%274 = call double @sin(double %273)
%275 = fmul double 0xBEDD4821CE8EBA4A, %274
store double %275, double* %53
br label %277
276: ; preds = %266, %255
store double 0.000000e+00, double* %53
br label %277
277: ; preds = %276, %269
%278 = load double, double* %44
%279 = load double, double* %43
%280 = fmul double %278, %279
%281 = load double, double* %46
%282 = load double, double* %43
%283 = fsub double %282, 1.000000e+00
%284 = call double @pow(double %281, double %283)
%285 = fmul double %280, %284
%286 = load double, double* %52
%287 = load double, double* %48
%288 = load double, double* %53
%289 = fmul double %287, %288
%290 = call double @llvm.fmuladd.f64(double %285, double %286, double %289)
store double %290, double* %54
%291 = load double, double* %54
%292 = fcmp ogt double %291, 0.000000e+00
br i1 %292, label %293, label %304
293: ; preds = %277
%294 = load i32, i32* @stderr
%295 = call i32 @fprintf(i32 %294, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.2, i64 0, i64 0))
%296 = load double*, double** %82
%297 = call i32 @free(double* %296)
%298 = load double*, double** %78
%299 = call i32 @free(double* %298)
%300 = load double*, double** %79
%301 = call i32 @free(double* %300)
%302 = load double*, double** %80
%303 = call i32 @free(double* %302)
store i32 2, i32* %13
br label %923
304: ; preds = %277
%305 = load double, double* %49
%306 = fmul double 8.314000e+00, %305
%307 = load double, double* %51
%308 = load double, double* %77
%309 = fadd double %307, %308
%310 = fmul double %306, %309
%311 = fdiv double 6.000000e+04, %310
store double %311, double* %55
%312 = load double, double* %49
%313 = fmul double 8.314000e+00, %312
%314 = fdiv double -6.000000e+04, %313
%315 = call double @exp(double %314)
store double %315, double* %56
%316 = call double @pow(double 8.927100e+03, double 3.000000e+00)
%317 = fmul double 2.000000e+00, %316
%318 = fmul double %317, 3.615000e-13
store double %318, double* %57
%319 = load double, double* %57
%320 = load double, double* %54
%321 = fneg double %320
%322 = call double @pow(double %321, double 3.000000e+00)
%323 = fmul double %319, %322
%324 = load double, double* %56
%325 = fmul double %323, %324
%326 = load double, double* %55
%327 = call double @pow(double %326, double -4.000000e+00)
%328 = fmul double %325, %327
store double %328, double* %58
store i32 0, i32* %81
br label %329
329: ; preds = %416, %304
%330 = load i32, i32* %81
%331 = load i32, i32* %17
%332 = icmp slt i32 %330, %331
br i1 %332, label %333, label %419
333: ; preds = %329
%334 = load double*, double** %16
%335 = load i32, i32* %81
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds double, double* %334, i64 %336
%338 = load double, double* %337
%339 = load double, double* %77
%340 = fcmp olt double %338, %339
br i1 %340, label %341, label %388
341: ; preds = %333
%342 = load double, double* %55
%343 = load double, double* %77
%344 = fmul double %342, %343
%345 = call double @p3(double %344)
%346 = load double, double* %55
%347 = load double, double* %77
%348 = fmul double %346, %347
%349 = call double @exp(double %348)
%350 = load double, double* %55
%351 = load double, double* %77
%352 = load double*, double** %16
%353 = load i32, i32* %81
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double, double* %352, i64 %354
%356 = load double, double* %355
%357 = fsub double %351, %356
%358 = fmul double %350, %357
%359 = call double @p3(double %358)
%360 = load double, double* %55
%361 = load double, double* %77
%362 = load double*, double** %16
%363 = load i32, i32* %81
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds double, double* %362, i64 %364
%366 = load double, double* %365
%367 = fsub double %361, %366
%368 = fmul double %360, %367
%369 = call double @exp(double %368)
%370 = fmul double %359, %369
%371 = fneg double %370
%372 = call double @llvm.fmuladd.f64(double %345, double %349, double %371)
%373 = load double*, double** %82
%374 = load i32, i32* %81
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double, double* %373, i64 %375
store double %372, double* %376
%377 = load double, double* %58
%378 = load double*, double** %82
%379 = load i32, i32* %81
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %378, i64 %380
%382 = load double, double* %381
%383 = fmul double %377, %382
%384 = load double*, double** %78
%385 = load i32, i32* %81
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
store double %383, double* %387
br label %415
388: ; preds = %333
%389 = load double, double* %55
%390 = load double, double* %77
%391 = fmul double %389, %390
%392 = call double @p3(double %391)
%393 = load double, double* %55
%394 = load double, double* %77
%395 = fmul double %393, %394
%396 = call double @exp(double %395)
%397 = call double @p3(double 0.000000e+00)
%398 = fneg double %397
%399 = call double @llvm.fmuladd.f64(double %392, double %396, double %398)
%400 = load double*, double** %82
%401 = load i32, i32* %81
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %400, i64 %402
store double %399, double* %403
%404 = load double, double* %58
%405 = load double*, double** %82
%406 = load i32, i32* %81
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %405, i64 %407
%409 = load double, double* %408
%410 = fmul double %404, %409
%411 = load double*, double** %78
%412 = load i32, i32* %81
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %411, i64 %413
store double %410, double* %414
br label %415
415: ; preds = %388, %341
br label %416
416: ; preds = %415
%417 = load i32, i32* %81
%418 = add nsw i32 %417, 1
store i32 %418, i32* %81
br label %329
419: ; preds = %329
store i32 0, i32* %81
br label %420
420: ; preds = %477, %419
%421 = load i32, i32* %81
%422 = load i32, i32* %17
%423 = icmp slt i32 %421, %422
br i1 %423, label %424, label %480
424: ; preds = %420
%425 = load double*, double** %16
%426 = load i32, i32* %81
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds double, double* %425, i64 %427
%429 = load double, double* %428
%430 = load double, double* %77
%431 = fcmp olt double %429, %430
br i1 %431, label %432, label %471
432: ; preds = %424
%433 = load double, double* %51
%434 = load double*, double** %16
%435 = load i32, i32* %81
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %434, i64 %436
%438 = load double, double* %437
%439 = fadd double %433, %438
%440 = fmul double 6.000000e+04, %439
%441 = fneg double %440
%442 = load double, double* %49
%443 = fmul double 8.314000e+00, %442
%444 = load double, double* %51
%445 = load double, double* %77
%446 = fadd double %444, %445
%447 = fmul double %443, %446
%448 = fdiv double %441, %447
store double %448, double* %59
%449 = load double, double* %57
%450 = fmul double %449, 9.810000e+00
%451 = fdiv double %450, 2.009000e+03
%452 = load double, double* %59
%453 = call double @exp(double %452)
%454 = fmul double %451, %453
%455 = load double, double* %54
%456 = call double @llvm.fabs.f64(double %455)
%457 = load double, double* %77
%458 = load double*, double** %16
%459 = load i32, i32* %81
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %458, i64 %460
%462 = load double, double* %461
%463 = fsub double %457, %462
%464 = fmul double %456, %463
%465 = call double @pow(double %464, double 4.000000e+00)
%466 = fmul double %454, %465
%467 = load double*, double** %80
%468 = load i32, i32* %81
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds double, double* %467, i64 %469
store double %466, double* %470
br label %476
471: ; preds = %424
%472 = load double*, double** %80
%473 = load i32, i32* %81
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %472, i64 %474
store double 0.000000e+00, double* %475
br label %476
476: ; preds = %471, %432
br label %477
477: ; preds = %476
%478 = load i32, i32* %81
%479 = add nsw i32 %478, 1
store i32 %479, i32* %81
br label %420
480: ; preds = %420
%481 = load double, double* %45
%482 = fsub double 1.000000e+00, %481
%483 = call double @pow(double %482, double 0xBFE5555555555556)
%484 = load double, double* %45
%485 = call double @pow(double %484, double 0xBFE5555555555556)
%486 = fsub double %483, %485
%487 = fmul double 0x3D6BCCCCA63597CF, %486
store double %487, double* %60
%488 = load double, double* %15
%489 = fcmp ogt double %488, 2.250000e+05
br i1 %489, label %490, label %500
490: ; preds = %480
%491 = load double, double* %15
%492 = fcmp olt double %491, 6.750000e+05
br i1 %492, label %493, label %500
493: ; preds = %490
%494 = load double, double* %15
%495 = fsub double %494, 4.500000e+05
%496 = fmul double 0x401921FB54442D11, %495
%497 = fdiv double %496, 4.500000e+05
%498 = call double @cos(double %497)
%499 = fmul double 0xBDDACB5FDEA7EB29, %498
store double %499, double* %61
br label %501
500: ; preds = %490, %480
store double 0.000000e+00, double* %61
br label %501
501: ; preds = %500, %493
%502 = load double, double* %44
%503 = load double, double* %43
%504 = fmul double %502, %503
%505 = load double, double* %43
%506 = fsub double %505, 1.000000e+00
%507 = fmul double %504, %506
%508 = load double, double* %46
%509 = load double, double* %43
%510 = fsub double %509, 2.000000e+00
%511 = call double @pow(double %508, double %510)
%512 = fmul double %507, %511
%513 = load double, double* %52
%514 = call double @pow(double %513, double 2.000000e+00)
%515 = load double, double* %44
%516 = load double, double* %43
%517 = fmul double %515, %516
%518 = load double, double* %46
%519 = load double, double* %43
%520 = fsub double %519, 1.000000e+00
%521 = call double @pow(double %518, double %520)
%522 = fmul double %517, %521
%523 = load double, double* %60
%524 = fmul double %522, %523
%525 = call double @llvm.fmuladd.f64(double %512, double %514, double %524)
%526 = load double, double* %48
%527 = load double, double* %61
%528 = call double @llvm.fmuladd.f64(double %526, double %527, double %525)
store double %528, double* %62
store double 1.670000e-05, double* %63
%529 = load double, double* %63
%530 = fmul double 2.100000e+00, %529
%531 = fdiv double %530, 8.400000e-02
%532 = load double, double* %50
%533 = fadd double 1.000000e+00, %532
%534 = load double, double* %49
%535 = fdiv double 1.000000e+00, %534
%536 = load double, double* %54
%537 = load double, double* %49
%538 = load double, double* %77
%539 = load double, double* %63
%540 = fmul double %538, %539
%541 = fneg double %540
%542 = call double @llvm.fmuladd.f64(double %536, double %537, double %541)
%543 = fmul double %535, %542
%544 = load double, double* %50
%545 = fdiv double %543, %544
%546 = call double @llvm.fmuladd.f64(double %531, double %533, double %545)
store double %546, double* %64
%547 = load double, double* %49
%548 = fmul double 8.314000e+00, %547
%549 = load double, double* %49
%550 = fmul double %548, %549
%551 = load double, double* %51
%552 = load double, double* %77
%553 = fadd double %551, %552
%554 = call double @pow(double %553, double 2.000000e+00)
%555 = fmul double %550, %554
%556 = fdiv double -6.000000e+04, %555
%557 = load double, double* %63
%558 = load double, double* %51
%559 = load double, double* %77
%560 = fadd double %558, %559
%561 = load double, double* %49
%562 = load double, double* %64
%563 = load double, double* %54
%564 = fadd double %562, %563
%565 = fmul double %561, %564
%566 = call double @llvm.fmuladd.f64(double %557, double %560, double %565)
%567 = fmul double %556, %566
store double %567, double* %65
%568 = load double, double* %15
%569 = fdiv double 1.000000e+00, %568
%570 = load double, double* %62
%571 = fmul double 3.000000e+00, %570
%572 = load double, double* %54
%573 = fdiv double %571, %572
%574 = fadd double %569, %573
%575 = load double, double* %63
%576 = fmul double 6.000000e+04, %575
%577 = load double, double* %49
%578 = fmul double 8.314000e+00, %577
%579 = load double, double* %49
%580 = fmul double %578, %579
%581 = fdiv double %576, %580
%582 = fadd double %574, %581
%583 = load double, double* %65
%584 = fmul double 4.000000e+00, %583
%585 = load double, double* %55
%586 = fdiv double %584, %585
%587 = fsub double %582, %586
store double %587, double* %66
%588 = load double, double* %55
%589 = call double @pow(double %588, double 3.000000e+00)
%590 = load double, double* %55
%591 = load double, double* %77
%592 = fmul double %590, %591
%593 = call double @exp(double %592)
%594 = fmul double %589, %593
%595 = load double, double* %65
%596 = load double, double* %77
%597 = load double, double* %55
%598 = load double, double* %54
%599 = fmul double %597, %598
%600 = call double @llvm.fmuladd.f64(double %595, double %596, double %599)
%601 = fmul double %594, %600
%602 = load double, double* %77
%603 = call double @pow(double %602, double 3.000000e+00)
%604 = fmul double %601, %603
store double %604, double* %67
store i32 0, i32* %81
br label %605
605: ; preds = %680, %501
%606 = load i32, i32* %81
%607 = load i32, i32* %17
%608 = icmp slt i32 %606, %607
br i1 %608, label %609, label %683
609: ; preds = %605
%610 = load double, double* %55
%611 = load double, double* %77
%612 = fmul double %610, %611
%613 = call double @p4(double %612)
%614 = load double, double* %55
%615 = load double, double* %77
%616 = fmul double %614, %615
%617 = call double @exp(double %616)
%618 = load double, double* %55
%619 = load double, double* %77
%620 = load double*, double** %16
%621 = load i32, i32* %81
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds double, double* %620, i64 %622
%624 = load double, double* %623
%625 = fsub double %619, %624
%626 = fmul double %618, %625
%627 = call double @p4(double %626)
%628 = load double, double* %55
%629 = load double, double* %77
%630 = load double*, double** %16
%631 = load i32, i32* %81
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds double, double* %630, i64 %632
%634 = load double, double* %633
%635 = fsub double %629, %634
%636 = fmul double %628, %635
%637 = call double @exp(double %636)
%638 = fmul double %627, %637
%639 = fneg double %638
%640 = call double @llvm.fmuladd.f64(double %613, double %617, double %639)
store double %640, double* %72
%641 = load double, double* %58
%642 = load double, double* %65
%643 = load double, double* %55
%644 = fdiv double %642, %643
%645 = load double, double* %66
%646 = fsub double %644, %645
%647 = load double, double* %72
%648 = fmul double %646, %647
%649 = load double, double* %55
%650 = fdiv double %648, %649
%651 = load double, double* %66
%652 = load double, double* %77
%653 = load double*, double** %16
%654 = load i32, i32* %81
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds double, double* %653, i64 %655
%657 = load double, double* %656
%658 = fsub double %652, %657
%659 = load double, double* %54
%660 = call double @llvm.fmuladd.f64(double %651, double %658, double %659)
%661 = load double*, double** %82
%662 = load i32, i32* %81
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds double, double* %661, i64 %663
%665 = load double, double* %664
%666 = call double @llvm.fmuladd.f64(double %660, double %665, double %650)
%667 = load double, double* %67
%668 = load double*, double** %16
%669 = load i32, i32* %81
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %668, i64 %670
%672 = load double, double* %671
%673 = fneg double %667
%674 = call double @llvm.fmuladd.f64(double %673, double %672, double %666)
%675 = fmul double %641, %674
%676 = load double*, double** %79
%677 = load i32, i32* %81
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds double, double* %676, i64 %678
store double %675, double* %679
br label %680
680: ; preds = %609
%681 = load i32, i32* %81
%682 = add nsw i32 %681, 1
store i32 %682, i32* %81
br label %605
683: ; preds = %605
%684 = load double, double* %55
%685 = load double, double* %77
%686 = fmul double %684, %685
%687 = call double @p4(double %686)
%688 = load double, double* %55
%689 = load double, double* %77
%690 = fmul double %688, %689
%691 = call double @exp(double %690)
%692 = call double @llvm.fmuladd.f64(double %687, double %691, double -2.400000e+01)
store double %692, double* %68
%693 = load double, double* %58
%694 = fneg double %693
%695 = load double, double* %65
%696 = load double, double* %55
%697 = fdiv double %695, %696
%698 = load double, double* %66
%699 = fsub double %697, %698
%700 = fmul double %694, %699
%701 = load double, double* %68
%702 = fmul double %700, %701
%703 = load double, double* %55
%704 = fdiv double %702, %703
%705 = load double, double* %58
%706 = load double, double* %67
%707 = fmul double %705, %706
%708 = load double, double* %77
%709 = call double @llvm.fmuladd.f64(double %707, double %708, double %704)
store double %709, double* %69
%710 = load double, double* %18
%711 = fmul double %710, 2.000000e+00
%712 = fmul double %711, 0x400921FB54442D11
%713 = fdiv double %712, 0x422D63C1E8C00000
%714 = load double, double* %14
%715 = fmul double 0x401921FB54442D11, %714
%716 = fdiv double %715, 0x422D63C1E8C00000
%717 = call double @cos(double %716)
%718 = fmul double %713, %717
%719 = load double, double* %47
%720 = fmul double %718, %719
store double %720, double* %70
%721 = load double, double* %70
%722 = load double, double* %69
%723 = fadd double %721, %722
%724 = load double*, double** %20
store double %723, double* %724
%725 = load double, double* %70
%726 = load double, double* %50
%727 = fdiv double %725, %726
store double %727, double* %71
store i32 0, i32* %81
br label %728
728: ; preds = %873, %683
%729 = load i32, i32* %81
%730 = load i32, i32* %17
%731 = icmp slt i32 %729, %730
br i1 %731, label %732, label %876
732: ; preds = %728
%733 = load double*, double** %16
%734 = load i32, i32* %81
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds double, double* %733, i64 %735
%737 = load double, double* %736
%738 = load double, double* %77
%739 = fcmp olt double %737, %738
br i1 %739, label %740, label %867
740: ; preds = %732
%741 = load double, double* %49
%742 = load double, double* %71
%743 = load double, double* %70
%744 = fadd double %742, %743
%745 = load double, double* %51
%746 = load double*, double** %16
%747 = load i32, i32* %81
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds double, double* %746, i64 %748
%750 = load double, double* %749
%751 = fadd double %745, %750
%752 = load double, double* %51
%753 = load double, double* %77
%754 = fadd double %752, %753
%755 = load double, double* %71
%756 = fmul double %754, %755
%757 = fneg double %756
%758 = call double @llvm.fmuladd.f64(double %744, double %751, double %757)
%759 = fmul double %741, %758
%760 = load double, double* %51
%761 = load double*, double** %16
%762 = load i32, i32* %81
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds double, double* %761, i64 %763
%765 = load double, double* %764
%766 = fadd double %760, %765
%767 = call double @pow(double %766, double -2.000000e+00)
%768 = fmul double %759, %767
store double %768, double* %73
%769 = load double, double* %63
%770 = load double, double* %51
%771 = load double, double* %77
%772 = fadd double %770, %771
%773 = fmul double %769, %772
%774 = load double, double* %51
%775 = load double*, double** %16
%776 = load i32, i32* %81
%777 = sext i32 %776 to i64
%778 = getelementptr inbounds double, double* %775, i64 %777
%779 = load double, double* %778
%780 = fadd double %774, %779
%781 = fdiv double %773, %780
%782 = load double, double* %49
%783 = load double, double* %64
%784 = load double, double* %54
%785 = fadd double %783, %784
%786 = load double, double* %51
%787 = load double*, double** %16
%788 = load i32, i32* %81
%789 = sext i32 %788 to i64
%790 = getelementptr inbounds double, double* %787, i64 %789
%791 = load double, double* %790
%792 = fadd double %786, %791
%793 = load double, double* %51
%794 = load double, double* %77
%795 = fadd double %793, %794
%796 = load double, double* %64
%797 = fmul double %795, %796
%798 = fneg double %797
%799 = call double @llvm.fmuladd.f64(double %785, double %792, double %798)
%800 = fmul double %782, %799
%801 = load double, double* %51
%802 = load double*, double** %16
%803 = load i32, i32* %81
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds double, double* %802, i64 %804
%806 = load double, double* %805
%807 = fadd double %801, %806
%808 = call double @pow(double %807, double -2.000000e+00)
%809 = call double @llvm.fmuladd.f64(double %800, double %808, double %781)
store double %809, double* %74
%810 = load double, double* %49
%811 = fneg double %810
%812 = load double, double* %51
%813 = load double, double* %77
%814 = fadd double %812, %813
%815 = fmul double %811, %814
%816 = load double, double* %51
%817 = load double*, double** %16
%818 = load i32, i32* %81
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds double, double* %817, i64 %819
%821 = load double, double* %820
%822 = fadd double %816, %821
%823 = call double @pow(double %822, double -2.000000e+00)
%824 = fmul double %815, %823
store double %824, double* %75
%825 = load double, double* %49
%826 = fmul double 2.000000e+00, %825
%827 = load double, double* %51
%828 = load double, double* %77
%829 = fadd double %827, %828
%830 = fmul double %826, %829
%831 = load double, double* %51
%832 = load double*, double** %16
%833 = load i32, i32* %81
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds double, double* %832, i64 %834
%836 = load double, double* %835
%837 = fadd double %831, %836
%838 = call double @pow(double %837, double -3.000000e+00)
%839 = fmul double %830, %838
store double %839, double* %76
%840 = load double, double* %73
%841 = load double*, double** %78
%842 = load i32, i32* %81
%843 = sext i32 %842 to i64
%844 = getelementptr inbounds double, double* %841, i64 %843
%845 = load double, double* %844
%846 = load double, double* %74
%847 = call double @llvm.fmuladd.f64(double %845, double %846, double %840)
%848 = load double*, double** %79
%849 = load i32, i32* %81
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds double, double* %848, i64 %850
%852 = load double, double* %851
%853 = load double, double* %75
%854 = call double @llvm.fmuladd.f64(double %852, double %853, double %847)
%855 = load double, double* %76
%856 = call double @llvm.fmuladd.f64(double 0xBEB34587D5E72893, double %855, double %854)
%857 = load double*, double** %80
%858 = load i32, i32* %81
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds double, double* %857, i64 %859
%861 = load double, double* %860
%862 = fsub double %856, %861
%863 = load double*, double** %25
%864 = load i32, i32* %81
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds double, double* %863, i64 %865
store double %862, double* %866
br label %872
867: ; preds = %732
%868 = load double*, double** %25
%869 = load i32, i32* %81
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds double, double* %868, i64 %870
store double 0.000000e+00, double* %871
br label %872
872: ; preds = %867, %740
br label %873
873: ; preds = %872
%874 = load i32, i32* %81
%875 = add nsw i32 %874, 1
store i32 %875, i32* %81
br label %728
876: ; preds = %728
%877 = load double, double* %77
%878 = load double*, double** %19
store double %877, double* %878
store i32 0, i32* %81
br label %879
879: ; preds = %911, %876
%880 = load i32, i32* %81
%881 = load i32, i32* %17
%882 = icmp slt i32 %880, %881
br i1 %882, label %883, label %914
883: ; preds = %879
%884 = load double*, double** %78
%885 = load i32, i32* %81
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %884, i64 %886
%888 = load double, double* %887
%889 = load double*, double** %22
%890 = load i32, i32* %81
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds double, double* %889, i64 %891
store double %888, double* %892
%893 = load double*, double** %79
%894 = load i32, i32* %81
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds double, double* %893, i64 %895
%897 = load double, double* %896
%898 = load double*, double** %23
%899 = load i32, i32* %81
%900 = sext i32 %899 to i64
%901 = getelementptr inbounds double, double* %898, i64 %900
store double %897, double* %901
%902 = load double*, double** %80
%903 = load i32, i32* %81
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds double, double* %902, i64 %904
%906 = load double, double* %905
%907 = load double*, double** %24
%908 = load i32, i32* %81
%909 = sext i32 %908 to i64
%910 = getelementptr inbounds double, double* %907, i64 %909
store double %906, double* %910
br label %911
911: ; preds = %883
%912 = load i32, i32* %81
%913 = add nsw i32 %912, 1
store i32 %913, i32* %81
br label %879
914: ; preds = %879
%915 = load double*, double** %82
%916 = call i32 @free(double* %915)
%917 = load double*, double** %78
%918 = call i32 @free(double* %917)
%919 = load double*, double** %79
%920 = call i32 @free(double* %919)
%921 = load double*, double** %80
%922 = call i32 @free(double* %921)
store i32 0, i32* %13
br label %923
923: ; preds = %914, %293, %144, %129, %114, %101, %90
%924 = load i32, i32* %13
ret i32 %924
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [28 x i8] c"\0A memory allocation failed\0A\00"
@.str.1 = [58 x i8] c"\0AERROR bothexact(): code and derivation assume 0<r<L !\0A\0A\00"
@.str.2 = [59 x i8] c"\0AERROR bothexact(): assumes H_r negative for all 0<r<L !\0A\0A\00"
define i32 @bothexact(double %0, double %1, double* nocapture %2, i32 %3, double %4, double* nocapture writeonly %5, double* nocapture writeonly %6, double* nocapture writeonly %7, double* nocapture writeonly %8, double* nocapture writeonly %9, double* nocapture writeonly %10, double* nocapture writeonly %11) {
%13 = sext i32 %3 to i64
%14 = shl nsw i64 %13, 3
%15 = tail call i64 @malloc(i64 %14)
%16 = inttoptr i64 %15 to double*
%17 = icmp eq i64 %15, 0
br i1 %17, label %18, label %21
18: ; preds = %12
%19 = load i32, i32* @stderr
%20 = tail call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
br label %446
21: ; preds = %12
%22 = tail call i64 @malloc(i64 %14)
%23 = inttoptr i64 %22 to double*
%24 = icmp eq i64 %22, 0
br i1 %24, label %25, label %29
25: ; preds = %21
%26 = load i32, i32* @stderr
%27 = tail call i32 @fprintf(i32 %26, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%28 = tail call i32 @free(double* %16)
br label %446
29: ; preds = %21
%30 = tail call i64 @malloc(i64 %14)
%31 = inttoptr i64 %30 to double*
%32 = icmp eq i64 %30, 0
br i1 %32, label %33, label %38
33: ; preds = %29
%34 = load i32, i32* @stderr
%35 = tail call i32 @fprintf(i32 %34, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%36 = tail call i32 @free(double* %16)
%37 = tail call i32 @free(double* %23)
br label %446
38: ; preds = %29
%39 = tail call i64 @malloc(i64 %14)
%40 = inttoptr i64 %39 to double*
%41 = icmp eq i64 %39, 0
br i1 %41, label %42, label %48
42: ; preds = %38
%43 = load i32, i32* @stderr
%44 = tail call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%45 = tail call i32 @free(double* %16)
%46 = tail call i32 @free(double* %23)
%47 = tail call i32 @free(double* %31)
br label %446
48: ; preds = %38
%49 = fcmp ole double %1, 0.000000e+00
%50 = fcmp oge double %1, 7.500000e+05
%51 = or i1 %49, %50
br i1 %51, label %52, label %59
52: ; preds = %48
%53 = load i32, i32* @stderr
%54 = tail call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.1, i64 0, i64 0))
%55 = tail call i32 @free(double* %16)
%56 = tail call i32 @free(double* %23)
%57 = tail call i32 @free(double* %31)
%58 = tail call i32 @free(double* %40)
br label %446
59: ; preds = %48
%60 = fdiv double %1, 7.500000e+05
%61 = tail call double @llvm.fmuladd.f64(double %60, double 0x3FF5555555555555, double 0xBFD5555555555555)
%62 = fsub double 1.000000e+00, %60
%63 = tail call double @pow(double %62, double 0x3FF5555555555555)
%64 = fadd double %61, %63
%65 = tail call double @pow(double %60, double 0x3FF5555555555555)
%66 = fsub double %64, %65
%67 = fcmp ogt double %1, 2.250000e+05
%68 = fcmp olt double %1, 6.750000e+05
%69 = and i1 %67, %68
br i1 %69, label %70, label %76
70: ; preds = %59
%71 = fadd double %1, -4.500000e+05
%72 = fmul double %71, 0x400921FB54442D11
%73 = fdiv double %72, 4.500000e+05
%74 = tail call double @cos(double %73)
%75 = fmul double %74, %74
br label %76
76: ; preds = %59, %70
%77 = phi double [ %75, %70 ], [ 0.000000e+00, %59 ]
%78 = fmul double %0, 0x401921FB54442D11
%79 = fdiv double %78, 0x422D63C1E8C00000
%80 = tail call double @sin(double %79)
%81 = fmul double %80, %4
%82 = tail call double @pow(double %66, double 3.750000e-01)
%83 = fmul double %77, %81
%84 = tail call double @llvm.fmuladd.f64(double %82, double 0x40AB494E7CDD0C8A, double %83)
%85 = tail call double @llvm.fmuladd.f64(double %1, double 1.670000e-05, double 2.231500e+02)
%86 = fmul double %84, 4.000000e+00
%87 = fmul double %86, 4.200000e-02
%88 = fmul double %85, 2.100000e+00
%89 = fdiv double %87, %88
%90 = fadd double %89, 1.000000e+00
%91 = fptosi double %90 to i32
%92 = tail call double @sqrt(i32 %91)
%93 = fdiv double %88, 8.400000e-02
%94 = fadd double %92, 1.000000e+00
%95 = fmul double %93, %94
%96 = icmp sgt i32 %3, 0
br i1 %96, label %97, label %143
97: ; preds = %76
%98 = fadd double %84, %95
%99 = fmul double %85, %98
%100 = zext i32 %3 to i64
%101 = and i64 %100, 1
%102 = icmp eq i32 %3, 1
br i1 %102, label %130, label %103
103: ; preds = %97
%104 = and i64 %100, 4294967294
br label %105
105: ; preds = %124, %103
%106 = phi i64 [ 0, %103 ], [ %127, %124 ]
%107 = phi i64 [ 0, %103 ], [ %128, %124 ]
%108 = getelementptr inbounds double, double* %2, i64 %106
%109 = load double, double* %108
%110 = fcmp olt double %109, %84
br i1 %110, label %111, label %114
111: ; preds = %105
%112 = fadd double %95, %109
%113 = fdiv double %99, %112
br label %114
114: ; preds = %105, %111
%115 = phi double [ %113, %111 ], [ %85, %105 ]
%116 = getelementptr inbounds double, double* %7, i64 %106
store double %115, double* %116
%117 = or i64 %106, 1
%118 = getelementptr inbounds double, double* %2, i64 %117
%119 = load double, double* %118
%120 = fcmp olt double %119, %84
br i1 %120, label %121, label %124
121: ; preds = %114
%122 = fadd double %95, %119
%123 = fdiv double %99, %122
br label %124
124: ; preds = %121, %114
%125 = phi double [ %123, %121 ], [ %85, %114 ]
%126 = getelementptr inbounds double, double* %7, i64 %117
store double %125, double* %126
%127 = add nuw nsw i64 %106, 2
%128 = add i64 %107, 2
%129 = icmp eq i64 %128, %104
br i1 %129, label %130, label %105
130: ; preds = %124, %97
%131 = phi i64 [ 0, %97 ], [ %127, %124 ]
%132 = icmp eq i64 %101, 0
br i1 %132, label %143, label %133
133: ; preds = %130
%134 = getelementptr inbounds double, double* %2, i64 %131
%135 = load double, double* %134
%136 = fcmp olt double %135, %84
br i1 %136, label %137, label %140
137: ; preds = %133
%138 = fadd double %95, %135
%139 = fdiv double %99, %138
br label %140
140: ; preds = %137, %133
%141 = phi double [ %139, %137 ], [ %85, %133 ]
%142 = getelementptr inbounds double, double* %7, i64 %131
store double %141, double* %142
br label %143
143: ; preds = %140, %130, %76
%144 = tail call double @pow(double %62, double 0x3FD5555555555555)
%145 = fsub double 1.000000e+00, %144
%146 = tail call double @pow(double %60, double 0x3FD5555555555555)
%147 = fsub double %145, %146
%148 = fmul double %147, 0x3EBDD37F5698C2C2
br i1 %69, label %149, label %155
149: ; preds = %143
%150 = fadd double %1, -4.500000e+05
%151 = fmul double %150, 0x401921FB54442D11
%152 = fdiv double %151, 4.500000e+05
%153 = tail call double @sin(double %152)
%154 = fmul double %153, 0xBEDD4821CE8EBA4A
br label %155
155: ; preds = %143, %149
%156 = phi double [ %154, %149 ], [ 0.000000e+00, %143 ]
%157 = tail call double @pow(double %66, double -6.250000e-01)
%158 = fmul double %157, 0x409476FADDA5C968
%159 = fmul double %81, %156
%160 = tail call double @llvm.fmuladd.f64(double %158, double %148, double %159)
%161 = fcmp ogt double %160, 0.000000e+00
br i1 %161, label %162, label %169
162: ; preds = %155
%163 = load i32, i32* @stderr
%164 = tail call i32 @fprintf(i32 %163, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.2, i64 0, i64 0))
%165 = tail call i32 @free(double* %16)
%166 = tail call i32 @free(double* %23)
%167 = tail call i32 @free(double* %31)
%168 = tail call i32 @free(double* %40)
br label %446
169: ; preds = %155
%170 = fmul double %85, 8.314000e+00
%171 = fadd double %84, %95
%172 = fmul double %170, %171
%173 = fdiv double 6.000000e+04, %172
%174 = fdiv double -6.000000e+04, %170
%175 = tail call double @exp(double %174)
%176 = fneg double %160
%177 = tail call double @pow(double %176, double 3.000000e+00)
%178 = fmul double %177, 0x3FE075A8D64FEA2F
%179 = fmul double %175, %178
%180 = tail call double @pow(double %173, double -4.000000e+00)
%181 = fmul double %180, %179
br i1 %96, label %182, label %239
182: ; preds = %169
%183 = fmul double %84, %173
%184 = zext i32 %3 to i64
br label %189
185: ; preds = %210
br i1 %96, label %186, label %239
186: ; preds = %185
%187 = tail call double @llvm.fabs.f64(double %160)
%188 = zext i32 %3 to i64
br label %218
189: ; preds = %182, %210
%190 = phi i64 [ 0, %182 ], [ %216, %210 ]
%191 = getelementptr inbounds double, double* %2, i64 %190
%192 = load double, double* %191
%193 = fcmp olt double %192, %84
%194 = tail call double @p3(double %183)
%195 = tail call double @exp(double %183)
br i1 %193, label %196, label %207
196: ; preds = %189
%197 = load double, double* %191
%198 = fsub double %84, %197
%199 = fmul double %173, %198
%200 = tail call double @p3(double %199)
%201 = load double, double* %191
%202 = fsub double %84, %201
%203 = fmul double %173, %202
%204 = tail call double @exp(double %203)
%205 = fneg double %200
%206 = fmul double %204, %205
br label %210
207: ; preds = %189
%208 = tail call double @p3(double 0.000000e+00)
%209 = fneg double %208
br label %210
210: ; preds = %196, %207
%211 = phi double [ %206, %196 ], [ %209, %207 ]
%212 = tail call double @llvm.fmuladd.f64(double %194, double %195, double %211)
%213 = fmul double %181, %212
%214 = getelementptr inbounds double, double* %16, i64 %190
store double %212, double* %214
%215 = getelementptr inbounds double, double* %23, i64 %190
store double %213, double* %215
%216 = add nuw nsw i64 %190, 1
%217 = icmp eq i64 %216, %184
br i1 %217, label %185, label %189
218: ; preds = %186, %234
%219 = phi i64 [ 0, %186 ], [ %237, %234 ]
%220 = getelementptr inbounds double, double* %2, i64 %219
%221 = load double, double* %220
%222 = fcmp olt double %221, %84
br i1 %222, label %223, label %234
223: ; preds = %218
%224 = fadd double %95, %221
%225 = fmul double %224, -6.000000e+04
%226 = fdiv double %225, %172
%227 = tail call double @exp(double %226)
%228 = fmul double %227, 0x3F64934E1BE6D0E0
%229 = load double, double* %220
%230 = fsub double %84, %229
%231 = fmul double %187, %230
%232 = tail call double @pow(double %231, double 4.000000e+00)
%233 = fmul double %228, %232
br label %234
234: ; preds = %218, %223
%235 = phi double [ %233, %223 ], [ 0.000000e+00, %218 ]
%236 = getelementptr inbounds double, double* %40, i64 %219
store double %235, double* %236
%237 = add nuw nsw i64 %219, 1
%238 = icmp eq i64 %237, %188
br i1 %238, label %239, label %218
239: ; preds = %234, %169, %185
%240 = tail call double @pow(double %62, double 0xBFE5555555555556)
%241 = tail call double @pow(double %60, double 0xBFE5555555555556)
%242 = fsub double %240, %241
%243 = fmul double %242, 0x3D6BCCCCA63597CF
br i1 %69, label %244, label %250
244: ; preds = %239
%245 = fadd double %1, -4.500000e+05
%246 = fmul double %245, 0x401921FB54442D11
%247 = fdiv double %246, 4.500000e+05
%248 = tail call double @cos(double %247)
%249 = fmul double %248, 0xBDDACB5FDEA7EB29
br label %250
250: ; preds = %239, %244
%251 = phi double [ %249, %244 ], [ 0.000000e+00, %239 ]
%252 = tail call double @pow(double %66, double -1.625000e+00)
%253 = fmul double %252, 0xC08994B9950F3BC2
%254 = fmul double %148, %148
%255 = tail call double @pow(double %66, double -6.250000e-01)
%256 = fmul double %255, 0x409476FADDA5C968
%257 = fmul double %243, %256
%258 = tail call double @llvm.fmuladd.f64(double %253, double %254, double %257)
%259 = tail call double @llvm.fmuladd.f64(double %81, double %251, double %258)
%260 = fdiv double 1.000000e+00, %85
%261 = fmul double %84, -1.670000e-05
%262 = tail call double @llvm.fmuladd.f64(double %160, double %85, double %261)
%263 = fmul double %260, %262
%264 = fdiv double %263, %92
%265 = tail call double @llvm.fmuladd.f64(double %94, double 4.175000e-04, double %264)
%266 = fmul double %85, %170
%267 = fmul double %171, %171
%268 = fmul double %266, %267
%269 = fdiv double -6.000000e+04, %268
%270 = fadd double %160, %265
%271 = fmul double %85, %270
%272 = tail call double @llvm.fmuladd.f64(double %171, double 1.670000e-05, double %271)
%273 = fmul double %269, %272
%274 = fdiv double 1.000000e+00, %1
%275 = fmul double %259, 3.000000e+00
%276 = fdiv double %275, %160
%277 = fadd double %274, %276
%278 = fdiv double 1.002000e+00, %266
%279 = fadd double %278, %277
%280 = fmul double %273, 4.000000e+00
%281 = fdiv double %280, %173
%282 = fsub double %279, %281
%283 = tail call double @pow(double %173, double 3.000000e+00)
%284 = fmul double %84, %173
%285 = tail call double @exp(double %284)
%286 = fmul double %283, %285
%287 = fmul double %173, %160
%288 = tail call double @llvm.fmuladd.f64(double %273, double %84, double %287)
%289 = fmul double %288, %286
%290 = tail call double @pow(double %84, double 3.000000e+00)
%291 = fmul double %290, %289
%292 = fdiv double %273, %173
%293 = fsub double %292, %282
br i1 %96, label %294, label %326
294: ; preds = %250
%295 = fneg double %291
%296 = zext i32 %3 to i64
br label %297
297: ; preds = %294, %297
%298 = phi i64 [ 0, %294 ], [ %324, %297 ]
%299 = tail call double @p4(double %284)
%300 = tail call double @exp(double %284)
%301 = getelementptr inbounds double, double* %2, i64 %298
%302 = load double, double* %301
%303 = fsub double %84, %302
%304 = fmul double %173, %303
%305 = tail call double @p4(double %304)
%306 = load double, double* %301
%307 = fsub double %84, %306
%308 = fmul double %173, %307
%309 = tail call double @exp(double %308)
%310 = fneg double %305
%311 = fmul double %309, %310
%312 = tail call double @llvm.fmuladd.f64(double %299, double %300, double %311)
%313 = fmul double %293, %312
%314 = fdiv double %313, %173
%315 = load double, double* %301
%316 = fsub double %84, %315
%317 = tail call double @llvm.fmuladd.f64(double %282, double %316, double %160)
%318 = getelementptr inbounds double, double* %16, i64 %298
%319 = load double, double* %318
%320 = tail call double @llvm.fmuladd.f64(double %317, double %319, double %314)
%321 = tail call double @llvm.fmuladd.f64(double %295, double %315, double %320)
%322 = fmul double %181, %321
%323 = getelementptr inbounds double, double* %31, i64 %298
store double %322, double* %323
%324 = add nuw nsw i64 %298, 1
%325 = icmp eq i64 %324, %296
br i1 %325, label %326, label %297
326: ; preds = %297, %250
%327 = tail call double @p4(double %284)
%328 = tail call double @exp(double %284)
%329 = tail call double @llvm.fmuladd.f64(double %327, double %328, double -2.400000e+01)
%330 = fneg double %181
%331 = fmul double %293, %330
%332 = fmul double %331, %329
%333 = fdiv double %332, %173
%334 = fmul double %181, %291
%335 = tail call double @llvm.fmuladd.f64(double %334, double %84, double %333)
%336 = fmul double %4, 2.000000e+00
%337 = fmul double %336, 0x400921FB54442D11
%338 = fdiv double %337, 0x422D63C1E8C00000
%339 = tail call double @cos(double %79)
%340 = fmul double %338, %339
%341 = fmul double %77, %340
%342 = fadd double %341, %335
store double %342, double* %6
%343 = fdiv double %341, %92
br i1 %96, label %345, label %344
344: ; preds = %326
store double %84, double* %5
br label %441
345: ; preds = %326
%346 = fadd double %341, %343
%347 = fneg double %171
%348 = fmul double %343, %347
%349 = fmul double %171, 1.670000e-05
%350 = fmul double %265, %347
%351 = fneg double %85
%352 = fmul double %171, %351
%353 = fmul double %85, 2.000000e+00
%354 = fmul double %353, %171
%355 = zext i32 %3 to i64
br label %356
356: ; preds = %345, %392
%357 = phi i64 [ 0, %345 ], [ %395, %392 ]
%358 = getelementptr inbounds double, double* %2, i64 %357
%359 = load double, double* %358
%360 = fcmp olt double %359, %84
br i1 %360, label %361, label %392
361: ; preds = %356
%362 = fadd double %95, %359
%363 = tail call double @llvm.fmuladd.f64(double %346, double %362, double %348)
%364 = fmul double %85, %363
%365 = tail call double @pow(double %362, double -2.000000e+00)
%366 = fmul double %364, %365
%367 = load double, double* %358
%368 = fadd double %95, %367
%369 = fdiv double %349, %368
%370 = tail call double @llvm.fmuladd.f64(double %270, double %368, double %350)
%371 = fmul double %85, %370
%372 = tail call double @pow(double %368, double -2.000000e+00)
%373 = tail call double @llvm.fmuladd.f64(double %371, double %372, double %369)
%374 = load double, double* %358
%375 = fadd double %95, %374
%376 = tail call double @pow(double %375, double -2.000000e+00)
%377 = fmul double %352, %376
%378 = load double, double* %358
%379 = fadd double %95, %378
%380 = tail call double @pow(double %379, double -3.000000e+00)
%381 = fmul double %354, %380
%382 = getelementptr inbounds double, double* %23, i64 %357
%383 = load double, double* %382
%384 = tail call double @llvm.fmuladd.f64(double %383, double %373, double %366)
%385 = getelementptr inbounds double, double* %31, i64 %357
%386 = load double, double* %385
%387 = tail call double @llvm.fmuladd.f64(double %386, double %377, double %384)
%388 = tail call double @llvm.fmuladd.f64(double %381, double 0xBEB34587D5E72893, double %387)
%389 = getelementptr inbounds double, double* %40, i64 %357
%390 = load double, double* %389
%391 = fsub double %388, %390
br label %392
392: ; preds = %356, %361
%393 = phi double [ %391, %361 ], [ 0.000000e+00, %356 ]
%394 = getelementptr inbounds double, double* %11, i64 %357
store double %393, double* %394
%395 = add nuw nsw i64 %357, 1
%396 = icmp eq i64 %395, %355
br i1 %396, label %397, label %356
397: ; preds = %392
store double %84, double* %5
br i1 %96, label %398, label %441
398: ; preds = %397
%399 = and i64 %355, 1
%400 = icmp eq i32 %3, 1
br i1 %400, label %428, label %401
401: ; preds = %398
%402 = and i64 %355, 4294967294
br label %403
403: ; preds = %403, %401
%404 = phi i64 [ 0, %401 ], [ %425, %403 ]
%405 = phi i64 [ 0, %401 ], [ %426, %403 ]
%406 = getelementptr inbounds double, double* %23, i64 %404
%407 = load double, double* %406
%408 = getelementptr inbounds double, double* %8, i64 %404
store double %407, double* %408
%409 = getelementptr inbounds double, double* %31, i64 %404
%410 = load double, double* %409
%411 = getelementptr inbounds double, double* %9, i64 %404
store double %410, double* %411
%412 = getelementptr inbounds double, double* %40, i64 %404
%413 = load double, double* %412
%414 = getelementptr inbounds double, double* %10, i64 %404
store double %413, double* %414
%415 = or i64 %404, 1
%416 = getelementptr inbounds double, double* %23, i64 %415
%417 = load double, double* %416
%418 = getelementptr inbounds double, double* %8, i64 %415
store double %417, double* %418
%419 = getelementptr inbounds double, double* %31, i64 %415
%420 = load double, double* %419
%421 = getelementptr inbounds double, double* %9, i64 %415
store double %420, double* %421
%422 = getelementptr inbounds double, double* %40, i64 %415
%423 = load double, double* %422
%424 = getelementptr inbounds double, double* %10, i64 %415
store double %423, double* %424
%425 = add nuw nsw i64 %404, 2
%426 = add i64 %405, 2
%427 = icmp eq i64 %426, %402
br i1 %427, label %428, label %403
428: ; preds = %403, %398
%429 = phi i64 [ 0, %398 ], [ %425, %403 ]
%430 = icmp eq i64 %399, 0
br i1 %430, label %441, label %431
431: ; preds = %428
%432 = getelementptr inbounds double, double* %23, i64 %429
%433 = load double, double* %432
%434 = getelementptr inbounds double, double* %8, i64 %429
store double %433, double* %434
%435 = getelementptr inbounds double, double* %31, i64 %429
%436 = load double, double* %435
%437 = getelementptr inbounds double, double* %9, i64 %429
store double %436, double* %437
%438 = getelementptr inbounds double, double* %40, i64 %429
%439 = load double, double* %438
%440 = getelementptr inbounds double, double* %10, i64 %429
store double %439, double* %440
br label %441
441: ; preds = %431, %428, %344, %397
%442 = tail call i32 @free(double* %16)
%443 = tail call i32 @free(double* %23)
%444 = tail call i32 @free(double* %31)
%445 = tail call i32 @free(double* %40)
br label %446
446: ; preds = %441, %162, %52, %42, %33, %25, %18
%447 = phi i32 [ -9999, %18 ], [ -9999, %25 ], [ -9999, %33 ], [ -9999, %42 ], [ 1, %52 ], [ 2, %162 ], [ 0, %441 ]
ret i32 %447
}