#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 exp(double);
double fabs(double);
double log(double);
double pow(double, double);
double sqrt(double);
void computeVariables(double voi, double *states, double *rates,
                      double *variables) {
  variables[91] = states[32];
  variables[93] = variables[91] / (variables[71] + variables[91]);
  variables[95] = variables[8] * states[1] * (states[4] - states[30]);
  variables[96] = states[4] - states[30];
  variables[97] =
      variables[2] - (variables[2] - variables[3]) /
                         (1.0 + pow(variables[0] / states[4], variables[1]));
  variables[98] = variables[6] / variables[97];
  variables[99] = variables[4] * variables[97];
  variables[100] = states[0] + states[1] + states[2] + states[3];
  variables[103] = (states[30] - states[12]) / variables[27];
  variables[104] = variables[102] /
                   (1.0 + exp((-states[12] + variables[24]) / variables[26]));
  variables[105] = (states[13] - states[4]) / variables[28];
  variables[106] = variables[21] * states[12] * (1.0 - states[6]) -
                   variables[16] * states[6];
  variables[107] =
      variables[22] * states[12] * (1.0 - (states[7] + states[8])) -
      variables[17] * states[7];
  variables[108] =
      variables[23] * variables[11] * (1.0 - (states[7] + states[8])) -
      variables[18] * states[8];
  variables[109] = variables[19] * states[12] * (1.0 - states[9]) -
                   variables[14] * states[9];
  variables[110] = variables[19] * states[30] * (1.0 - states[10]) -
                   variables[14] * states[10];
  variables[111] = variables[20] * states[4] * (1.0 - states[11]) -
                   variables[15] * states[11];
  variables[126] = variables[117] * log((variables[38] + 0.12 * variables[37]) /
                                        (variables[91] + 0.12 * variables[36]));
  variables[131] = variables[54] / (variables[54] + states[30]);
  variables[132] = 0.001 * variables[131] / variables[55];
  variables[134] = variables[117] * log((variables[37] + 0.12 * variables[38]) /
                                        (variables[36] + 0.12 * variables[91]));
  variables[137] = variables[117] * log(variables[38] / variables[91]);
  variables[139] = 0.5 * variables[117] * log(variables[35] / states[30]);
  variables[140] = (variables[43] >= 1.0) ? variables[118] : states[31];
  variables[141] = states[14] * variables[122] *
                   (variables[140] - variables[137]) * (1.0 - variables[87]);
  variables[142] = states[14] * variables[123] *
                   (variables[140] - variables[138]) * (1.0 - variables[87]);
  variables[143] = variables[141] + variables[142];
  variables[144] =
      1.0 / (0.36 * (variables[140] + 148.8 - variables[124] - variables[125]) /
                 (exp(0.066 * (variables[140] + 148.8 - variables[124] -
                               variables[125])) -
                  1.0) +
             0.1 * (variables[140] + 87.3 - variables[124] - variables[125]) /
                 (1.0 - exp(-0.2 * (variables[140] + 87.3 - variables[124] -
                                    variables[125])))) -
      0.054;
  variables[145] =
      (variables[140] <
       -(80.0 - variables[124] - variables[125] - variables[89]))
          ? 0.01329 +
                0.99921 / (1.0 + exp((variables[140] + 97.134 - variables[124] -
                                      variables[125] - variables[89]) /
                                     8.1752))
          : 0.0002501 * exp(-(variables[140] - variables[124] - variables[125] -
                              variables[89]) /
                            12.861);
  variables[146] = variables[65] * pow(states[15], 3.0) * states[16] *
                   (variables[140] - variables[126]);
  variables[147] =
      variables[66] * pow(states[15], 3.0) * (variables[140] - variables[126]);
  variables[148] = variables[146] + variables[147];
  variables[149] = 1.0 / (1.0 + exp(-(variables[140] + 42.0504) / 8.3106));
  variables[150] = variables[140] + 41.0;
  variables[151] =
      (fabs(variables[150]) < variables[84])
          ? 2000.0
          : 200.0 * variables[150] / (1.0 - exp(-0.1 * variables[150]));
  variables[152] = 8000.0 * exp(-0.056 * (variables[140] + 66.0));
  variables[153] = 1.0 / (variables[151] + variables[152]);
  variables[154] = 1.0 / (1.0 + exp((variables[140] + 69.804) / 4.4565));
  variables[155] = 20.0 * exp(-0.125 * (variables[140] + 75.0));
  variables[156] = 2000.0 / (320.0 * exp(-0.1 * (variables[140] + 75.0)) + 1.0);
  variables[157] = 1.0 / (variables[155] + variables[156]);
  variables[158] = variables[64] * states[26] * states[27] *
                   (variables[140] - variables[138]);
  variables[159] = 1.0 / (1.0 + exp((variables[140] + 6.0) / -8.6));
  variables[160] = 0.009 / (1.0 + exp((variables[140] + 5.0) / 12.0)) + 0.0005;
  variables[161] = 1.0 / (1.0 + exp((variables[140] + 7.5) / 10.0));
  variables[162] = 0.59 / (1.0 + exp((variables[140] + 60.0) / 10.0)) + 3.05;
  variables[163] =
      2.0 * variables[51] * (variables[140] - 0.0) /
      (variables[117] *
       (1.0 - exp(-1.0 * (variables[140] - 0.0) * 2.0 / variables[117]))) *
      (states[30] -
       variables[35] * exp(-2.0 * (variables[140] - 0.0) / variables[117])) *
      states[29] * states[17] * states[5];
  variables[164] =
      0.000365 * variables[51] * (variables[140] - 0.0) /
      (variables[117] *
       (1.0 - exp(-1.0 * (variables[140] - 0.0) / variables[117]))) *
      (variables[36] -
       variables[37] * exp(-1.0 * (variables[140] - 0.0) / variables[117])) *
      states[29] * states[17] * states[5];
  variables[165] =
      0.0000185 * variables[51] * (variables[140] - 0.0) /
      (variables[117] *
       (1.0 - exp(-1.0 * (variables[140] - 0.0) / variables[117]))) *
      (variables[91] -
       variables[38] * exp(-1.0 * (variables[140] - 0.0) / variables[117])) *
      states[29] * states[17] * states[5];
  variables[166] = (variables[163] + variables[164] + variables[165]) *
                   (1.0 - variables[128]) * 1.0 * variables[127];
  variables[167] =
      1.0 / (1.0 + exp(-(variables[140] - variables[52] - variables[129]) /
                       (variables[53] * (1.0 + variables[130] / 100.0))));
  variables[168] = (variables[140] == -41.8)  ? -41.80001
                   : (variables[140] == 0.0)  ? 0.0
                   : (variables[140] == -6.8) ? -6.80001
                                              : variables[140];
  variables[169] = (variables[140] == -1.8) ? -1.80001 : variables[140];
  variables[170] = 1.0 / (1.0 + exp((variables[140] + 37.4 + variables[57]) /
                                    (5.3 + variables[56])));
  variables[171] =
      0.001 * (44.3 + 230.0 * exp(-pow((variables[140] + 36.0) / 10.0, 2.0)));
  variables[172] = 2.0 * variables[58] * variables[140] /
                   (variables[117] *
                    (1.0 - exp(-1.0 * variables[140] * 2.0 / variables[117]))) *
                   (states[30] - variables[35] * exp(-2.0 * variables[140] /
                                                     variables[117])) *
                   states[18] * states[19];
  variables[173] = 1.0 / (1.0 + exp(-(variables[140] + 38.3) / 5.5));
  variables[174] = 0.001 / (1.068 * exp((variables[140] + 38.3) / 30.0) +
                            1.068 * exp(-(variables[140] + 38.3) / 30.0));
  variables[175] = 1.0 / (1.0 + exp((variables[140] + 58.7) / 3.8));
  variables[176] = 1.0 / (16.67 * exp(-(variables[140] + 75.0) / 83.3) +
                          16.67 * exp((variables[140] + 75.0) / 15.38)) +
                   variables[59];
  variables[177] = variables[90] * (variables[140] - variables[138]) *
                   states[20] * states[21];
  variables[178] = 1.0 / (1.0 + exp((variables[140] + 49.0) / 13.0));
  variables[179] = 0.001 * 0.6 *
                   (65.17 / (0.57 * exp(-0.08 * (variables[140] + 44.0)) +
                             0.065 * exp(0.1 * (variables[140] + 45.93))) +
                    10.1);
  variables[180] = 1.0 / (1.0 + exp(-(variables[140] - 19.3) / 15.0));
  variables[181] = 0.001 * 0.66 * 1.4 *
                   (15.59 / (1.037 * exp(0.09 * (variables[140] + 30.61)) +
                             0.369 * exp(-0.12 * (variables[140] + 23.84))) +
                    2.98);
  variables[182] = variables[62] * (variables[140] - variables[138]) *
                   (0.9 * states[23] + 0.1 * states[22]) * states[24];
  variables[183] = 1.0 / (1.0 + exp(-(variables[140] + 23.2) / 6.6)) /
                   (0.84655354 / (37.2 * exp(variables[140] / 11.9) +
                                  0.96 * exp(-variables[140] / 18.5)));
  variables[184] =
      4.0 * ((37.2 * exp(variables[140] / 15.9) +
              0.96 * exp(-variables[140] / 22.5)) /
                 0.84655354 -
             1.0 / (1.0 + exp(-(variables[140] + 23.2) / 10.6)) /
                 (0.84655354 / (37.2 * exp(variables[140] / 15.9) +
                                0.96 * exp(-variables[140] / 22.5))));
  variables[185] = 1.0 / (1.0 + exp(-(variables[140] + 10.0144) / 7.6607));
  variables[186] = 0.84655354 / (4.2 * exp(variables[140] / 17.0) +
                                 0.15 * exp(-variables[140] / 21.6));
  variables[187] =
      1.0 / (30.0 * exp(variables[140] / 10.0) + exp(-variables[140] / 12.0));
  variables[188] = 1.0 / (100.0 * exp(-variables[140] / 54.645) +
                          656.0 * exp(variables[140] / 106.157));
  variables[189] = 1.0 / (1.0 + exp((variables[140] + 28.6) / 17.1));
  variables[190] =
      variables[133] * (variables[140] - variables[134]) * pow(states[28], 2.0);
  variables[191] = sqrt(
      1.0 / (1.0 + exp(-(variables[140] + 0.6383 - variables[135]) / 10.7071)));
  variables[192] =
      28.0 / (1.0 + exp(-(variables[140] - 40.0 - variables[135]) / 3.0));
  variables[193] = 1.0 * exp(-(variables[140] - variables[135] - 5.0) / 25.0);
  variables[194] =
      (variables[45] > 0.0)
          ? variables[60] * variables[61] * (variables[140] - variables[138]) *
                (1.0 + exp((variables[140] + 20.0) / 20.0)) * states[25]
          : 0.0;
  variables[195] = 10.0 * exp(0.0133 * (variables[140] + 40.0));
  variables[196] = variables[136] / (variables[136] + variables[195]);
  variables[197] = 1.0 / (variables[136] + variables[195]);
  variables[198] =
      variables[92] * variables[83] *
      pow(1.0 + pow(variables[81] / variables[37], 1.2), -1.0) *
      pow(1.0 + pow(variables[82] / variables[91], 1.3), -1.0) *
      pow(1.0 + exp(-(variables[140] - variables[137] + 110.0) / 20.0), -1.0);
  variables[199] =
      exp(-variables[79] * variables[140] / (2.0 * variables[117]));
  variables[200] =
      1.0 +
      states[30] / variables[74] *
          (1.0 + exp(-variables[77] * variables[140] / variables[117]) +
           variables[91] / variables[75]) +
      variables[91] / variables[67] *
          (1.0 + variables[91] / variables[69] *
                     (1.0 + variables[91] / variables[71]));
  variables[201] = exp(variables[79] * variables[140] / (2.0 * variables[117]));
  variables[202] =
      1.0 +
      variables[35] / variables[76] *
          (1.0 + exp(variables[78] * variables[140] / variables[117])) +
      variables[38] / variables[68] *
          (1.0 + variables[38] / variables[70] *
                     (1.0 + variables[38] / variables[72]));
  variables[203] = -0.02839 * (variables[168] + 41.8) /
                       (exp(-(variables[168] + 41.8) / 2.5) - 1.0) -
                   0.0849 * (variables[168] + 6.8) /
                       (exp(-(variables[168] + 6.8) / 4.8) - 1.0);
  variables[204] = 0.01143 * (variables[169] + 1.8) /
                   (exp((variables[169] + 1.8) / 2.5) - 1.0);
  variables[205] = 1.0 / (variables[192] + variables[193]);
  variables[206] = states[30] / variables[74] *
                   exp(-variables[77] * variables[140] / variables[117]) /
                   variables[200];
  variables[207] =
      variables[91] / variables[67] * variables[91] / variables[69] *
      (1.0 + variables[91] / variables[71]) *
      exp(variables[79] * variables[140] / (2.0 * variables[117])) /
      variables[200];
  variables[208] = variables[35] / variables[76] *
                   exp(variables[78] * variables[140] / variables[117]) /
                   variables[202];
  variables[209] =
      variables[38] / variables[68] * variables[38] / variables[70] *
      (1.0 + variables[38] / variables[72]) *
      exp(-variables[79] * variables[140] / (2.0 * variables[117])) /
      variables[202];
  variables[210] = 0.001 / (variables[203] + variables[204]);
  variables[211] =
      variables[199] * variables[94] * (variables[209] + variables[208]) +
      variables[208] * variables[201] * (variables[93] + variables[199]);
  variables[212] =
      variables[201] * variables[93] * (variables[207] + variables[206]) +
      variables[199] * variables[206] * (variables[94] + variables[201]);
  variables[213] =
      variables[207] * variables[93] * (variables[209] + variables[208]) +
      variables[206] * variables[209] * (variables[93] + variables[199]);
  variables[214] =
      variables[209] * variables[94] * (variables[207] + variables[206]) +
      variables[207] * variables[208] * (variables[94] + variables[201]);
  variables[215] =
      (1.0 - variables[80]) * variables[73] *
      (variables[212] * variables[208] - variables[211] * variables[206]) /
      (variables[211] + variables[212] + variables[213] + variables[214]);
  variables[216] = variables[143] + variables[182] + variables[190] +
                   variables[177] + variables[198] + variables[215] +
                   variables[148] + variables[166] + variables[172] +
                   variables[194] + variables[158];
}


x86 assembly (clang, -O0):
<computeVariables>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x100(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x2d8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x238(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x2d8(%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x2e8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
subsd  0xf0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x2f8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xf0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x300(%rax)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
call   1050 <pow@plt>
movsd  -0x58(%rbp),%xmm1
movaps %xmm0,%xmm3
movsd  -0x50(%rbp),%xmm0
movsd  0x3da7(%rip),%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x308(%rax)
mov    -0x20(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x308(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x310(%rax)
mov    -0x20(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x308(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x318(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x320(%rax)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x60(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0xd8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x338(%rax)
mov    -0x20(%rbp),%rax
movsd  0x330(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
addsd  0xc0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0xd0(%rax),%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x48(%rbp),%xmm0
movsd  0x3c93(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x340(%rax)
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0xe0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x348(%rax)
mov    -0x20(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x3c34(%rip),%xmm2
subsd  0x30(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x30(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x350(%rax)
mov    -0x20(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x40(%rax),%xmm1
movsd  0x3bc0(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x38(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x358(%rax)
mov    -0x20(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x40(%rax),%xmm1
movsd  0x3b4d(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x40(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x360(%rax)
mov    -0x20(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x3ae8(%rip),%xmm2
subsd  0x48(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x48(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x368(%rax)
mov    -0x20(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xf0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x3a82(%rip),%xmm2
subsd  0x50(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x50(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x370(%rax)
mov    -0x20(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x3a1f(%rip),%xmm2
subsd  0x58(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x58(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x378(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x128(%rax),%xmm0
movsd  0x39bc(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x120(%rax),%xmm1
movsd  0x3994(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3f0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1b0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1b0(%rax),%xmm1
mov    -0x10(%rbp),%rax
addsd  0xf0(%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x418(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3933(%rip),%xmm0
mulsd  0x418(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x1b8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x420(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x128(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
movsd  0x38da(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x120(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm1
movsd  0x38b2(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x430(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x2d8(%rax),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x448(%rax)
mov    -0x20(%rbp),%rax
movsd  0x382f(%rip),%xmm0
mulsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  0xf0(%rax),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x458(%rax)
mov    -0x20(%rbp),%rax
movsd  0x158(%rax),%xmm0
movsd  0x37d1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     184f <computeVariables+0x70f>
mov    -0x20(%rbp),%rax
movsd  0x3b0(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1860 <computeVariables+0x720>
mov    -0x10(%rbp),%rax
movsd  0xf8(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x460(%rax)
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x3d0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x448(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x3752(%rip),%xmm1
subsd  0x2b8(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x468(%rax)
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x3d8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x450(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x36fd(%rip),%xmm1
subsd  0x2b8(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x470(%rax)
mov    -0x20(%rbp),%rax
movsd  0x468(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x470(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x478(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3705(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x36e5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x36c8(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x3698(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  0x3637(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x3656(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x3636(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x3619(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x35e9(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x70(%rbp),%xmm1
movaps %xmm0,%xmm3
movsd  -0x68(%rbp),%xmm0
movsd  0x359b(%rip),%xmm2
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  0x3587(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x35a3(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x480(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x3573(%rip),%xmm0
subsd  0x3e0(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x2c8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1b68 <computeVariables+0xa28>
mov    -0x20(%rbp),%rax
movsd  0x358e(%rip),%xmm0
addsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x2c8(%rax),%xmm0
movsd  0x3552(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x34be(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x352a(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x3516(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1bd4 <computeVariables+0xa94>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x2c8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x34b1(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x3495(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x488(%rax)
mov    -0x20(%rbp),%rax
movsd  0x208(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  0x349e(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3f0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x490(%rax)
mov    -0x20(%rbp),%rax
movsd  0x210(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  0x3431(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3f0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x498(%rax)
mov    -0x20(%rbp),%rax
movsd  0x490(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x498(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4a0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x33bd(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x338e(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x32e5(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x32d9(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4a8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x334d(%rip),%xmm0
addsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4b0(%rax),%xmm1
movaps 0x36b6(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x2a0(%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1d99 <computeVariables+0xc59>
movsd  0x3334(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1df1 <computeVariables+0xcb1>
mov    -0x20(%rbp),%rax
movsd  0x3313(%rip),%xmm0
mulsd  0x4b0(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x32ef(%rip),%xmm0
mulsd  0x4b0(%rax),%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x321f(%rip),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4b8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3387(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x336f(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x3353(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4c0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4b8(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x4c0(%rax),%xmm1
movsd  0x319b(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4c8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x32ff(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x32e7(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x315e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x3152(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4d0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3296(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x3296(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x327a(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4d8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3256(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x3196(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x322a(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x30c6(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x317a(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4e0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4d8(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x4e0(%rax),%xmm1
movsd  0x308a(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4e8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x200(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xd0(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xd8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x450(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4f0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3172(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x315a(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x3001(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2ff5(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4f8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3119(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x3101(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2fb8(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x30dc(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x30c8(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x500(%rax)
mov    -0x20(%rbp),%rax
movsd  0x30a4(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x3084(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2f63(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2f57(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x508(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3053(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x303b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2f1a(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x3016(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x3002(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x510(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2fde(%rip),%xmm0
mulsd  0x198(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2f68(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x2f7c(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x118(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x110(%rbp),%xmm0
ff
movsd  0x2e54(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2eed(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xf8(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xe8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x518(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2e59(%rip),%xmm0
mulsd  0x198(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2df3(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0xf0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0xe8(%rbp),%xmm0
ff
movsd  0x2ceb(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x120(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x128(%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2d6c(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xe8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x520(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2ce8(%rip),%xmm0
mulsd  0x198(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2c8a(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0xc8(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0x2b82(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2c03(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xe8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x528(%rax)
mov    -0x20(%rbp),%rax
movsd  0x518(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x520(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x528(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2a7b(%rip),%xmm1
subsd  0x400(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x2a67(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x3f8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x530(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x1a0(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x408(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1a8(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x410(%rax),%xmm3
movsd  0x2ac0(%rip),%xmm2
divsd  %xmm2,%xmm3
movsd  0x29e4(%rip),%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x29cb(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x29bf(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x538(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2a63(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    268a <computeVariables+0x154a>
jp     268a <computeVariables+0x154a>
movsd  0x2b33(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    2726 <computeVariables+0x15e6>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    26b9 <computeVariables+0x1579>
jp     26b9 <computeVariables+0x1579>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    2716 <computeVariables+0x15d6>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2ad3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    26f2 <computeVariables+0x15b2>
jp     26f2 <computeVariables+0x15b2>
movsd  0x2ac3(%rip),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    2706 <computeVariables+0x15c6>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x540(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2a6a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2773 <computeVariables+0x1633>
jp     2773 <computeVariables+0x1633>
movsd  0x2a5a(%rip),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
jmp    2787 <computeVariables+0x1647>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x548(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2c11(%rip),%xmm0
addsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x1c8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2be9(%rip),%xmm1
addsd  0x1c0(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2820(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2814(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x550(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2ba0(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x28f8(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x28d4(%rip),%xmm1
call   1050 <pow@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2b48(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x2b44(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x27b0(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x558(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2874(%rip),%xmm0
mulsd  0x1d0(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2818(%rip),%xmm0
mulsd  0x460(%rax),%xmm0
movsd  0x2828(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x1d0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  0x2700(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x27a8(%rip),%xmm0
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x1c0(%rbp),%xmm1
ff
movsd  -0x1b8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1b0(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x560(%rax)
mov    -0x20(%rbp),%rax
movsd  0x29b9(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x299a(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x25f9(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x25ed(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x568(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2959(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x27d9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x292c(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2795(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x1a8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x28e1(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x28d5(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x255d(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x570(%rax)
mov    -0x20(%rbp),%rax
movsd  0x28a1(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2889(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2508(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x24fc(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x578(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2640(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2821(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x25fc(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x27ec(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x1a0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x27c8(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x27bc(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2454(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
addsd  0x1d8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x580(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2d0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x450(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xa8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x588(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2730(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2718(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x23bf(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x23b3(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x590(%rax)
mov    -0x20(%rbp),%rax
movsd  0x26d7(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x26bf(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x269a(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x239a(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x198(%rbp),%xmm0
ff
movsd  0x2666(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x2652(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x263a(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x2626(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x2612(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x598(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x25e6(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x25bb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x22b2(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x22a6(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5a0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x257a(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2562(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x253d(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2525(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x190(%rbp),%xmm0
ff
movsd  0x2501(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x24ed(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x24d5(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x24c1(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x24ad(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5a8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1f0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x450(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0xb8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x21ed(%rip),%xmm2
mulsd  0xb0(%rax),%xmm2
movsd  0x2445(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xc0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x23f5(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x23e6(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2135(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2129(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x23a1(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x235d(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x188(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x180(%rbp),%xmm0
ff
movsd  0x2311(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  0x22fd(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x22ad(%rip),%xmm1
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5b8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x22dd(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2299(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x178(%rbp),%xmm0
ff
movsd  0x2275(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x2261(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x2211(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2261(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2232(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1fa1(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1f95(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x21ed(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x21a9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x170(%rbp),%xmm3
ff
movsd  -0x168(%rbp),%xmm1
ff
movaps %xmm0,%xmm4
movsd  -0x160(%rbp),%xmm0
ff
movsd  0x2175(%rip),%xmm2
mulsd  %xmm4,%xmm2
movsd  0x2161(%rip),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x2111(%rip),%xmm2
divsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2135(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5c0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2111(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x20e2(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1e89(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1e7d(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5c8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2099(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2055(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x158(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x2031(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x201d(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2005(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5d0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x1ed1(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1ebd(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x150(%rbp),%xmm1
ff
movsd  0x1f84(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1d5c(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5d8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1f31(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x1f04(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x148(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1ee0(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1da4(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1cc4(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5e0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1ea0(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x1e88(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1c87(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1c7b(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5e8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x428(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x430(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xe0(%rax),%xmm0
movsd  0x1d1f(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x140(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5f0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1de3(%rip),%xmm0
addsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x438(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1da8(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1bb7(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1bab(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5f8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x1d5a(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
subsd  0x438(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1bfb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1b42(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1d06(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x600(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x438(%rax),%xmm0
movsd  0x1c46(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1cab(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1acf(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x608(%rax)
mov    -0x20(%rbp),%rax
movsd  0x168(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    35ef <computeVariables+0x24af>
mov    -0x20(%rbp),%rax
movsd  0x1e0(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x1e8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x450(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x1bc6(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x1bb6(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x1e0(%rbp),%xmm0
ff
movsd  0x1a32(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xc8(%rax),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
jmp    35ff <computeVariables+0x24bf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
jmp    35ff <computeVariables+0x24bf>
movsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x610(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1bb9(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x1de9(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1acd(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x618(%rax)
mov    -0x20(%rbp),%rax
movsd  0x440(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x440(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x618(%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x620(%rax)
mov    -0x20(%rbp),%rax
movsd  0x440(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x618(%rax),%xmm1
movsd  0x1959(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x628(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2e0(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x298(%rax),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x288(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x128(%rax),%xmm0
movsd  0x1d19(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x18f9(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x19c5(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x248(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x290(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x2d8(%rax),%xmm0
movsd  0x1cb9(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x18a1(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x196d(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x240(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x448(%rax),%xmm0
movsd  0x1c59(%rip),%xmm1
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x199e(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1822(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x18ee(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x238(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x630(%rax)
mov    -0x20(%rbp),%rax
movsd  0x278(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x18b3(%rip),%xmm1
mulsd  0x3a8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x638(%rax)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x250(%rax),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x268(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x230(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x172b(%rip),%xmm0
addsd  %xmm2,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm2
mov    -0x20(%rbp),%rax
divsd  0x258(%rax),%xmm2
addsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm1
movsd  0x16ff(%rip),%xmm0
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x218(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm2
mov    -0x20(%rbp),%rax
divsd  0x228(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm4
mov    -0x20(%rbp),%rax
divsd  0x238(%rax),%xmm4
movsd  0x16ab(%rip),%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x169b(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x640(%rax)
mov    -0x20(%rbp),%rax
movsd  0x278(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1757(%rip),%xmm1
mulsd  0x3a8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x648(%rax)
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x260(%rax),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x270(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x228(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x15e6(%rip),%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm1
movsd  0x15d6(%rip),%xmm0
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x220(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm2
mov    -0x20(%rbp),%rax
divsd  0x230(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm4
mov    -0x20(%rbp),%rax
divsd  0x240(%rax),%xmm4
movsd  0x1582(%rip),%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x1572(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x650(%rax)
mov    -0x20(%rbp),%rax
movsd  0x193e(%rip),%xmm1
addsd  0x540(%rax),%xmm1
movsd  0x1936(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x1916(%rip),%xmm0
addsd  0x540(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x18bf(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x220(%rbp),%xmm0
ff
movsd  0x14e3(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x18a7(%rip),%xmm1
addsd  0x540(%rax),%xmm1
movsd  0x189f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x187f(%rip),%xmm0
addsd  0x540(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1850(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x218(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x210(%rbp),%xmm0
ff
movsd  0x1454(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x658(%rax)
mov    -0x20(%rbp),%rax
movsd  0x17f8(%rip),%xmm1
addsd  0x548(%rax),%xmm1
movsd  0x17f0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x17d0(%rip),%xmm0
addsd  0x548(%rax),%xmm0
movsd  0x17b8(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x208(%rbp),%xmm0
ff
movsd  0x13dc(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x660(%rax)
mov    -0x20(%rbp),%rax
movsd  0x600(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x608(%rax),%xmm1
movsd  0x13a8(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x668(%rax)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x250(%rax),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x268(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x200(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x640(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x670(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x218(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2d8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x228(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm2
mov    -0x20(%rbp),%rax
divsd  0x238(%rax),%xmm2
movsd  0x12c1(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x278(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1385(%rip),%xmm1
mulsd  0x3a8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1f8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x640(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x678(%rax)
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x260(%rax),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x270(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x650(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x680(%rax)
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x220(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x130(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x230(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm2
mov    -0x20(%rbp),%rax
divsd  0x240(%rax),%xmm2
movsd  0x1195(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x278(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1242(%rip),%xmm1
mulsd  0x3a8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x650(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x688(%rax)
mov    -0x20(%rbp),%rax
movsd  0x658(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x660(%rax),%xmm1
movsd  0x110a(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x690(%rax)
mov    -0x20(%rbp),%rax
movsd  0x638(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2f0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x688(%rax),%xmm2
mov    -0x20(%rbp),%rax
addsd  0x680(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x680(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x648(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x2e8(%rax),%xmm3
mov    -0x20(%rbp),%rax
addsd  0x638(%rax),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x698(%rax)
mov    -0x20(%rbp),%rax
movsd  0x648(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2e8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x678(%rax),%xmm2
mov    -0x20(%rbp),%rax
addsd  0x670(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x638(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x670(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x2f0(%rax),%xmm3
mov    -0x20(%rbp),%rax
addsd  0x648(%rax),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x6a0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x678(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2e8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x688(%rax),%xmm2
mov    -0x20(%rbp),%rax
addsd  0x680(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x670(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x688(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x2e8(%rax),%xmm3
mov    -0x20(%rbp),%rax
addsd  0x638(%rax),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x6a8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x688(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2f0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x678(%rax),%xmm2
mov    -0x20(%rbp),%rax
addsd  0x670(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x678(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x680(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x2f0(%rax),%xmm3
mov    -0x20(%rbp),%rax
addsd  0x648(%rax),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x6b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0xef6(%rip),%xmm0
subsd  0x280(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x248(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x6a0(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x680(%rax),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x698(%rax),%xmm2
mov    -0x20(%rbp),%rax
mulsd  0x670(%rax),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x698(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x6a0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x6a8(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x6b0(%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x6b8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x478(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x5b0(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x5f0(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x588(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x630(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x6b8(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x4a0(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x530(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x560(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x610(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x4f0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x6c0(%rax)
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeVariables>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %rdx,%rbx
mov    %rdi,%r14
movsd  0x100(%rdi),%xmm0
movsd  %xmm0,0x2d8(%rdx)
movsd  0x238(%rdx),%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2e8(%rdx)
movsd  0x40(%rdx),%xmm0
mulsd  0x8(%rdi),%xmm0
movsd  0x20(%rdi),%xmm1
subsd  0xf0(%rdi),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x2f8(%rdx)
movsd  0x20(%rdi),%xmm0
subsd  0xf0(%rdi),%xmm0
movsd  %xmm0,0x300(%rdx)
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,(%rsp)
subsd  0x18(%rdx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  (%rdx),%xmm0
movsd  0x8(%rdx),%xmm1
divsd  0x20(%rdi),%xmm0
call   1050 <pow@plt>
addsd  0x1e23(%rip),%xmm0
movsd  0x18(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  (%rsp),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x308(%rbx)
movsd  0x30(%rbx),%xmm1
movsd  0xc0(%rbx),%xmm0
divsd  %xmm2,%xmm1
movsd  %xmm1,0x310(%rbx)
mulsd  0x20(%rbx),%xmm2
movsd  %xmm2,0x318(%rbx)
movsd  (%r14),%xmm1
addsd  0x8(%r14),%xmm1
addsd  0x10(%r14),%xmm1
addsd  0x18(%r14),%xmm1
movsd  %xmm1,0x320(%rbx)
movsd  0xf0(%r14),%xmm1
subsd  0x60(%r14),%xmm1
divsd  0xd8(%rbx),%xmm1
movsd  %xmm1,0x338(%rbx)
movsd  0x330(%rbx),%xmm1
movsd  %xmm1,(%rsp)
subsd  0x60(%r14),%xmm0
divsd  0xd0(%rbx),%xmm0
call   1030 <exp@plt>
movsd  0x1d7c(%rip),%xmm5
addsd  %xmm5,%xmm0
movsd  (%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x340(%rbx)
movsd  0x68(%r14),%xmm0
subsd  0x20(%r14),%xmm0
divsd  0xe0(%rbx),%xmm0
movsd  %xmm0,0x348(%rbx)
movsd  0xa8(%rbx),%xmm0
movsd  0xb0(%rbx),%xmm1
mulsd  0x60(%r14),%xmm0
movsd  0x30(%r14),%xmm2
movapd %xmm5,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
mulsd  0x80(%rbx),%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,0x350(%rbx)
mulsd  0x60(%r14),%xmm1
movsd  0x38(%r14),%xmm0
movsd  0x40(%r14),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm5,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
mulsd  0x88(%rbx),%xmm0
subsd  %xmm0,%xmm3
movsd  %xmm3,0x358(%rbx)
movsd  0xb8(%rbx),%xmm0
mulsd  0x58(%rbx),%xmm0
movsd  0x40(%r14),%xmm1
movsd  0x38(%r14),%xmm2
addsd  %xmm1,%xmm2
movapd %xmm5,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
mulsd  0x90(%rbx),%xmm1
subsd  %xmm1,%xmm3
movsd  %xmm3,0x360(%rbx)
movsd  0x70(%rbx),%xmm0
movsd  0x98(%rbx),%xmm1
movsd  0x60(%r14),%xmm2
mulsd  %xmm1,%xmm2
movsd  0x48(%r14),%xmm3
movapd %xmm5,%xmm4
subsd  %xmm3,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm4
movsd  %xmm4,0x368(%rbx)
mulsd  0xf0(%r14),%xmm1
movsd  0x50(%r14),%xmm2
movapd %xmm5,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,0x370(%rbx)
movsd  0xa0(%rbx),%xmm0
mulsd  0x20(%r14),%xmm0
movsd  0x58(%r14),%xmm1
movapd %xmm5,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x78(%rbx),%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x378(%rbx)
movsd  0x3a8(%rbx),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x1bfa(%rip),%xmm2
movsd  0x128(%rbx),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x130(%rbx),%xmm0
movsd  0x120(%rbx),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x2d8(%rbx),%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x3f0(%rbx)
movsd  0x1b0(%rbx),%xmm0
movsd  0x3a8(%rbx),%xmm1
movsd  %xmm1,(%rsp)
movsd  0xf0(%r14),%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x418(%rbx)
mulsd  0x1b8e(%rip),%xmm0
divsd  0x1b8(%rbx),%xmm0
movsd  %xmm0,0x420(%rbx)
movsd  0x130(%rbx),%xmm0
movsd  0x1b66(%rip),%xmm1
mulsd  %xmm1,%xmm0
addsd  0x128(%rbx),%xmm0
mulsd  0x2d8(%rbx),%xmm1
addsd  0x120(%rbx),%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x430(%rbx)
movsd  0x3a8(%rbx),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x130(%rbx),%xmm0
divsd  0x2d8(%rbx),%xmm0
call   1040 <log@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x448(%rbx)
movsd  0x3a8(%rbx),%xmm0
mulsd  0x1b05(%rip),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x118(%rbx),%xmm0
divsd  0xf0(%r14),%xmm0
call   1040 <log@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x458(%rbx)
movsd  0x158(%rbx),%xmm0
lea    0x3b0(%rbx),%rax
movsd  0x1aae(%rip),%xmm3
ucomisd %xmm3,%xmm0
lea    0xf8(%r14),%rcx
cmovb  %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x460(%rbx)
movsd  0x70(%r14),%xmm1
mulsd  0x3d0(%rbx),%xmm1
movapd %xmm0,%xmm2
subsd  0x448(%rbx),%xmm2
subsd  0x2b8(%rbx),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm2
movsd  %xmm2,0x468(%rbx)
movsd  0x70(%r14),%xmm1
mulsd  0x3d8(%rbx),%xmm1
movapd %xmm0,%xmm4
subsd  0x450(%rbx),%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,0x470(%rbx)
addsd  %xmm2,%xmm4
movsd  %xmm4,0x478(%rbx)
addsd  0x1a43(%rip),%xmm0
subsd  0x3e0(%rbx),%xmm0
subsd  0x3e8(%rbx),%xmm0
movsd  0x1a33(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mulsd  0x1a2a(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1a25(%rip),%xmm0
movsd  (%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x460(%rbx),%xmm0
addsd  0x1a0f(%rip),%xmm0
subsd  0x3e0(%rbx),%xmm0
subsd  0x3e8(%rbx),%xmm0
movsd  0x19ff(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
mulsd  0x19f5(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1998(%rip),%xmm2
movapd %xmm2,%xmm1
subsd  %xmm0,%xmm1
movsd  0x18(%rsp),%xmm0
divsd  %xmm1,%xmm0
addsd  (%rsp),%xmm0
movapd %xmm0,%xmm1
movapd %xmm2,%xmm0
divsd  %xmm1,%xmm0
addsd  0x19c5(%rip),%xmm0
movsd  %xmm0,0x480(%rbx)
movsd  0x460(%rbx),%xmm0
movsd  0x2c8(%rbx),%xmm1
movsd  0x3e0(%rbx),%xmm2
movsd  0x19a5(%rip),%xmm4
subsd  %xmm2,%xmm4
movsd  0x3e8(%rbx),%xmm3
subsd  %xmm3,%xmm4
subsd  %xmm1,%xmm4
xorpd  0x1d79(%rip),%xmm4
ucomisd %xmm0,%xmm4
jbe    1720 <computeVariables+0x5e0>
addsd  0x1993(%rip),%xmm0
subsd  %xmm2,%xmm0
subsd  %xmm3,%xmm0
subsd  %xmm1,%xmm0
divsd  0x1987(%rip),%xmm0
call   1030 <exp@plt>
movapd %xmm0,%xmm1
addsd  0x18f6(%rip),%xmm1
movsd  0x1976(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1972(%rip),%xmm0
jmp    1741 <computeVariables+0x601>
subsd  %xmm2,%xmm0
subsd  %xmm3,%xmm0
subsd  %xmm1,%xmm0
divsd  0x1934(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x192f(%rip),%xmm0
movsd  %xmm0,0x488(%rbx)
movsd  0x208(%rbx),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x78(%r14),%xmm0
movsd  0x1934(%rip),%xmm1
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
mulsd  0x80(%r14),%xmm0
movsd  0x460(%rbx),%xmm1
subsd  0x3f0(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x490(%rbx)
movsd  0x210(%rbx),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x78(%r14),%xmm0
movsd  0x18ea(%rip),%xmm1
call   1050 <pow@plt>
mulsd  (%rsp),%xmm0
movsd  0x460(%rbx),%xmm1
movapd %xmm1,%xmm2
subsd  0x3f0(%rbx),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x498(%rbx)
addsd  0x490(%rbx),%xmm2
movsd  %xmm2,0x4a0(%rbx)
addsd  0x18b0(%rip),%xmm1
divsd  0x18b0(%rip),%xmm1
movapd %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x17f7(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4a8(%rbx)
movsd  0x2a0(%rbx),%xmm2
movsd  0x460(%rbx),%xmm0
movsd  0x187f(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x4b0(%rbx)
movapd 0x1c1b(%rip),%xmm3
andpd  %xmm1,%xmm3
movsd  0x1867(%rip),%xmm4
ucomisd %xmm3,%xmm2
ja     1896 <computeVariables+0x756>
movsd  0x1861(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
mulsd  0x1858(%rip),%xmm1
movapd %xmm1,%xmm0
call   1030 <exp@plt>
movsd  (%rsp),%xmm4
movsd  0x177a(%rip),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm4
movsd  0x460(%rbx),%xmm0
movsd  %xmm4,0x4b8(%rbx)
addsd  0x182a(%rip),%xmm0
mulsd  0x182a(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1825(%rip),%xmm0
movsd  %xmm0,0x4c0(%rbx)
addsd  0x4b8(%rbx),%xmm0
movsd  0x172d(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4c8(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x17f9(%rip),%xmm0
divsd  0x17f9(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x16fc(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4d0(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x17d4(%rip),%xmm0
mulsd  0x17d4(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x17cf(%rip),%xmm0
movsd  %xmm0,0x4d8(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x17a7(%rip),%xmm0
mulsd  0x176f(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x17aa(%rip),%xmm0
movsd  0x1692(%rip),%xmm2
addsd  %xmm2,%xmm0
movsd  0x173e(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4e0(%rbx)
addsd  0x4d8(%rbx),%xmm1
movapd %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x4e8(%rbx)
movsd  0x200(%rbx),%xmm1
mulsd  0xd0(%r14),%xmm1
mulsd  0xd8(%r14),%xmm1
movsd  0x460(%rbx),%xmm0
movapd %xmm0,%xmm2
subsd  0x450(%rbx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x4f0(%rbx)
addsd  0x1738(%rip),%xmm0
divsd  0x1738(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x160b(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4f8(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x1713(%rip),%xmm0
divsd  0x1713(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x15d6(%rip),%xmm0
movsd  0x1706(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x1702(%rip),%xmm1
movsd  %xmm1,0x500(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x16f2(%rip),%xmm0
divsd  0x16f2(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1595(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x508(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x16cd(%rip),%xmm0
divsd  0x16bd(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1560(%rip),%xmm0
movsd  0x16b8(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x16b4(%rip),%xmm1
movsd  %xmm1,0x510(%rbx)
movsd  0x198(%rbx),%xmm1
addsd  %xmm1,%xmm1
movsd  0x460(%rbx),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x3a8(%rbx),%xmm1
movsd  %xmm1,0x18(%rsp)
mulsd  0x1681(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1500(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x18(%rsp),%xmm1
movsd  (%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  0xf0(%r14),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x118(%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x460(%rbx),%xmm0
mulsd  0x162b(%rip),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x20(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  (%rsp),%xmm1
mulsd  0xe8(%r14),%xmm1
mulsd  0x88(%r14),%xmm1
mulsd  0x28(%r14),%xmm1
movsd  %xmm1,0x518(%rbx)
movsd  0x198(%rbx),%xmm1
mulsd  0x15e1(%rip),%xmm1
movsd  0x460(%rbx),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x3a8(%rbx),%xmm1
movsd  %xmm1,0x18(%rsp)
xorpd  0x1892(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1431(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x18(%rsp),%xmm1
movsd  (%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  0x120(%rbx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x128(%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x460(%rbx),%xmm0
xorpd  0x183d(%rip),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x20(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  (%rsp),%xmm1
mulsd  0xe8(%r14),%xmm1
mulsd  0x88(%r14),%xmm1
mulsd  0x28(%r14),%xmm1
movsd  %xmm1,0x520(%rbx)
movsd  0x198(%rbx),%xmm1
mulsd  0x151b(%rip),%xmm1
movsd  0x460(%rbx),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x3a8(%rbx),%xmm1
movsd  %xmm1,0x18(%rsp)
xorpd  0x17c4(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1363(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x18(%rsp),%xmm1
movsd  (%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  0x130(%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x2d8(%rbx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x460(%rbx),%xmm0
xorpd  0x176f(%rip),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x20(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  (%rsp),%xmm1
mulsd  0xe8(%r14),%xmm1
mulsd  0x88(%r14),%xmm1
mulsd  0x28(%r14),%xmm1
movsd  %xmm1,0x528(%rbx)
movsd  0x518(%rbx),%xmm0
addsd  0x520(%rbx),%xmm0
addsd  %xmm1,%xmm0
movsd  0x12c1(%rip),%xmm2
movapd %xmm2,%xmm1
subsd  0x400(%rbx),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x3f8(%rbx),%xmm1
movsd  %xmm1,0x530(%rbx)
movsd  0x460(%rbx),%xmm0
subsd  0x1a0(%rbx),%xmm0
subsd  0x408(%rbx),%xmm0
movsd  0x410(%rbx),%xmm1
xorpd  0x16c9(%rip),%xmm0
divsd  0x13f9(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  0x1a8(%rbx),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1254(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x538(%rbx)
movsd  0x460(%rbx),%xmm0
ucomisd 0x13cc(%rip),%xmm0
jne    1dda <computeVariables+0xc9a>
jp     1dda <computeVariables+0xc9a>
movsd  0x13b8(%rip),%xmm1
jmp    1e00 <computeVariables+0xcc0>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1de6 <computeVariables+0xca6>
jnp    1e00 <computeVariables+0xcc0>
ucomisd 0x13ba(%rip),%xmm0
jne    1dfc <computeVariables+0xcbc>
jp     1dfc <computeVariables+0xcbc>
movsd  0x13a6(%rip),%xmm1
jmp    1e00 <computeVariables+0xcc0>
movapd %xmm0,%xmm1
movsd  %xmm1,0x540(%rbx)
movsd  0x13a0(%rip),%xmm1
cmpeqsd %xmm0,%xmm1
movsd  0x139b(%rip),%xmm2
andpd  %xmm1,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movlpd %xmm1,0x548(%rbx)
addsd  0x1387(%rip),%xmm0
addsd  0x1c8(%rbx),%xmm0
movsd  0x1c0(%rbx),%xmm1
addsd  0x1377(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x119e(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x550(%rbx)
movsd  0x460(%rbx),%xmm1
addsd  0x134e(%rip),%xmm1
movsd  0x12c6(%rip),%xmm0
divsd  %xmm0,%xmm1
movapd 0x15ba(%rip),%xmm0
xorpd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x132d(%rip),%xmm0
addsd  0x132d(%rip),%xmm0
mulsd  0x1155(%rip),%xmm0
movsd  %xmm0,0x558(%rbx)
movsd  0x1d0(%rbx),%xmm1
movsd  0x3a8(%rbx),%xmm2
movsd  %xmm2,0x18(%rsp)
addsd  %xmm1,%xmm1
movsd  0x460(%rbx),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x127a(%rip),%xmm1
mulsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
call   1030 <exp@plt>
movsd  0x10f5(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x18(%rsp),%xmm1
movsd  (%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  0xf0(%r14),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x118(%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x1228(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x20(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  (%rsp),%xmm1
mulsd  0x90(%r14),%xmm1
mulsd  0x98(%r14),%xmm1
movsd  %xmm1,0x560(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x124c(%rip),%xmm0
divsd  0x124c(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x104f(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x568(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x1217(%rip),%xmm0
divsd  0x121f(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x11fd(%rip),%xmm0
addsd  0x460(%rbx),%xmm0
divsd  0x1205(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1200(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  (%rsp),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  0xfef(%rip),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x570(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x11d3(%rip),%xmm0
divsd  0x11d3(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xfae(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x578(%rbx)
movsd  0x460(%rbx),%xmm0
movsd  0x1086(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  0x11a2(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x1068(%rip),%xmm0
addsd  0x460(%rbx),%xmm0
divsd  0x1188(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1183(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  (%rsp),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  0xf3a(%rip),%xmm0
divsd  %xmm2,%xmm0
addsd  0x1d8(%rbx),%xmm0
movsd  %xmm0,0x580(%rbx)
movsd  0x460(%rbx),%xmm0
movapd %xmm0,%xmm1
subsd  0x450(%rbx),%xmm1
mulsd  0x2d0(%rbx),%xmm1
mulsd  0xa0(%r14),%xmm1
mulsd  0xa8(%r14),%xmm1
movsd  %xmm1,0x588(%rbx)
addsd  0x1120(%rip),%xmm0
divsd  0x1120(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xed3(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x590(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x10fb(%rip),%xmm0
mulsd  0x10fb(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x460(%rbx),%xmm0
addsd  0x10e9(%rip),%xmm0
mulsd  0xed1(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x10dc(%rip),%xmm0
movsd  (%rsp),%xmm1
mulsd  0x10d7(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x10d3(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x10cf(%rip),%xmm0
mulsd  0x10cf(%rip),%xmm0
movsd  %xmm0,0x598(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x10bf(%rip),%xmm0
divsd  0x10bf(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xe22(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x5a0(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x109a(%rip),%xmm0
mulsd  0x109a(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x460(%rbx),%xmm0
addsd  0x1088(%rip),%xmm0
mulsd  0x1088(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1083(%rip),%xmm0
movsd  (%rsp),%xmm1
mulsd  0x107e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x107a(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1076(%rip),%xmm0
mulsd  0x1076(%rip),%xmm0
movsd  %xmm0,0x5a8(%rbx)
movsd  0x460(%rbx),%xmm0
movapd %xmm0,%xmm1
subsd  0x450(%rbx),%xmm1
mulsd  0x1f0(%rbx),%xmm1
movsd  0xdba(%rip),%xmm3
mulsd  0xb0(%r14),%xmm3
movsd  0xb8(%r14),%xmm2
mulsd  0x1038(%rip),%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0xc0(%r14),%xmm2
movsd  %xmm2,0x5b0(%rbx)
addsd  0x101f(%rip),%xmm0
divsd  0x101f(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xd22(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xffd(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xfea(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0xfe5(%rip),%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  0xfdf(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xfdb(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  (%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x5b8(%rbx)
movsd  0x460(%rbx),%xmm0
divsd  0xfbe(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xfac(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0xf7f(%rip),%xmm0
movsd  (%rsp),%xmm1
mulsd  0xf7a(%rip),%xmm1
addsd  %xmm0,%xmm1
divsd  0xf76(%rip),%xmm1
movsd  %xmm1,(%rsp)
movsd  0xf39(%rip),%xmm0
addsd  0x460(%rbx),%xmm0
divsd  0xf71(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xc34(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xf36(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xf23(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0xef6(%rip),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0xef0(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xeec(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x18(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  (%rsp),%xmm0
subsd  %xmm1,%xmm0
mulsd  0xeed(%rip),%xmm0
movsd  %xmm0,0x5c0(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0xedd(%rip),%xmm0
divsd  0xedd(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xb88(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x5c8(%rbx)
movsd  0x460(%rbx),%xmm0
divsd  0xeb8(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xea6(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0xea1(%rip),%xmm0
movsd  (%rsp),%xmm1
mulsd  0xe9c(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xe40(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5d0(%rbx)
movsd  0x460(%rbx),%xmm0
divsd  0xc5c(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xe62(%rip),%xmm0
call   1030 <exp@plt>
movsd  (%rsp),%xmm1
mulsd  0xcd8(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xad4(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5d8(%rbx)
movsd  0x460(%rbx),%xmm0
divsd  0xe30(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0xe1e(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0xe19(%rip),%xmm0
movsd  (%rsp),%xmm1
mulsd  0xc0c(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xa78(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5e0(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0xdec(%rip),%xmm0
divsd  0xdec(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xa47(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x5e8(%rbx)
movsd  0x460(%rbx),%xmm0
movapd %xmm0,%xmm1
subsd  0x430(%rbx),%xmm1
mulsd  0x428(%rbx),%xmm1
movsd  0xe0(%r14),%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x5f0(%rbx)
addsd  0xd9a(%rip),%xmm0
subsd  0x438(%rbx),%xmm0
divsd  0xd92(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x9dd(%rip),%xmm2
movapd %xmm0,%xmm1
addsd  %xmm2,%xmm1
movapd %xmm2,%xmm0
divsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2643 <computeVariables+0x1503>
sqrtsd %xmm0,%xmm0
jmp    2648 <computeVariables+0x1508>
call   1060 <sqrt@plt>
movsd  %xmm0,0x5f8(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0xd50(%rip),%xmm0
subsd  0x438(%rbx),%xmm0
divsd  0xd48(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x983(%rip),%xmm0
movsd  0xd3b(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x600(%rbx)
movsd  0x460(%rbx),%xmm0
subsd  0x438(%rbx),%xmm0
addsd  0xd1f(%rip),%xmm0
divsd  0xd1f(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x608(%rbx)
movsd  0x168(%rbx),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jbe    2728 <computeVariables+0x15e8>
movsd  0x1e0(%rbx),%xmm1
mulsd  0x1e8(%rbx),%xmm1
movsd  0x460(%rbx),%xmm0
movapd %xmm0,%xmm2
subsd  0x450(%rbx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rsp)
movsd  0xa03(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
addsd  0x8e6(%rip),%xmm0
mulsd  (%rsp),%xmm0
mulsd  0xc8(%r14),%xmm0
movsd  %xmm0,0x610(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0xc98(%rip),%xmm0
mulsd  0xc98(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x9fb(%rip),%xmm0
movsd  %xmm0,0x618(%rbx)
movsd  0x440(%rbx),%xmm1
addsd  %xmm1,%xmm0
shufpd $0x2,0xcfe(%rip),%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x620(%rbx)
movsd  0x288(%rbx),%xmm0
movsd  0x2e0(%rbx),%xmm1
mulsd  0x298(%rbx),%xmm1
movsd  %xmm1,(%rsp)
divsd  0x128(%rbx),%xmm0
movsd  0xc39(%rip),%xmm1
call   1050 <pow@plt>
movsd  0x844(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
mulsd  (%rsp),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x290(%rbx),%xmm0
divsd  0x2d8(%rbx),%xmm0
movsd  0xc0a(%rip),%xmm1
call   1050 <pow@plt>
movsd  0x80d(%rip),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
mulsd  (%rsp),%xmm2
movsd  %xmm2,(%rsp)
movsd  0x460(%rbx),%xmm0
subsd  0x448(%rbx),%xmm0
addsd  0xbd7(%rip),%xmm0
divsd  0xbd7(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x7ca(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
mulsd  (%rsp),%xmm1
movsd  %xmm1,0x630(%rbx)
movsd  0x278(%rbx),%xmm0
movapd 0xbf5(%rip),%xmm1
xorpd  %xmm1,%xmm0
mulsd  0x460(%rbx),%xmm0
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x638(%rbx)
movsd  0xf0(%r14),%xmm0
divsd  0x250(%rbx),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x268(%rbx),%xmm0
xorpd  0xba6(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
movapd %xmm0,%xmm1
movsd  0x735(%rip),%xmm5
addsd  %xmm5,%xmm1
movsd  0x278(%rbx),%xmm0
movsd  0x2d8(%rbx),%xmm2
movapd %xmm2,%xmm3
divsd  0x258(%rbx),%xmm3
addsd  %xmm1,%xmm3
mulsd  (%rsp),%xmm3
addsd  %xmm5,%xmm3
movapd %xmm2,%xmm1
divsd  0x218(%rbx),%xmm1
movapd %xmm2,%xmm4
divsd  0x228(%rbx),%xmm4
divsd  0x238(%rbx),%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x640(%rbx)
mulsd  0x460(%rbx),%xmm0
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x648(%rbx)
movsd  0x118(%rbx),%xmm1
movsd  0x270(%rbx),%xmm0
divsd  0x260(%rbx),%xmm1
movsd  %xmm1,(%rsp)
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
movsd  0x66d(%rip),%xmm4
addsd  %xmm4,%xmm0
mulsd  (%rsp),%xmm0
movsd  0x130(%rbx),%xmm1
movapd %xmm1,%xmm2
divsd  0x220(%rbx),%xmm2
movapd %xmm1,%xmm3
divsd  0x230(%rbx),%xmm3
addsd  %xmm4,%xmm0
divsd  0x240(%rbx),%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x650(%rbx)
movsd  0x540(%rbx),%xmm0
addsd  0xa14(%rip),%xmm0
movsd  0xa14(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
divsd  0xa0b(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x61e(%rip),%xmm0
movsd  (%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x540(%rbx),%xmm0
addsd  0x9e8(%rip),%xmm0
movsd  0x9e8(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
divsd  0x9de(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x5d9(%rip),%xmm0
movsd  0x18(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  (%rsp),%xmm1
movsd  %xmm1,0x658(%rbx)
movsd  0x548(%rbx),%xmm0
addsd  0x9b2(%rip),%xmm0
movsd  0x9b2(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
divsd  0x9a9(%rip),%xmm0
call   1030 <exp@plt>
movhpd 0x600(%rbx),%xmm0
movapd 0x9cc(%rip),%xmm1
movhpd 0x608(%rbx),%xmm1
addpd  %xmm0,%xmm1
movapd (%rsp),%xmm0
shufpd $0x2,0x9a2(%rip),%xmm0
divpd  %xmm1,%xmm0
movupd %xmm0,0x660(%rbx)
movsd  0xf0(%r14),%xmm0
divsd  0x250(%rbx),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x268(%rbx),%xmm0
xorpd  0x950(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  (%rsp),%xmm0
divsd  0x640(%rbx),%xmm0
movsd  %xmm0,0x670(%rbx)
movsd  0x2d8(%rbx),%xmm2
movapd %xmm2,%xmm1
divsd  0x218(%rbx),%xmm1
mulsd  %xmm2,%xmm1
divsd  0x228(%rbx),%xmm1
divsd  0x238(%rbx),%xmm2
movsd  0x278(%rbx),%xmm0
addsd  0x49e(%rip),%xmm2
mulsd  0x460(%rbx),%xmm0
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rsp)
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  (%rsp),%xmm0
divsd  0x640(%rbx),%xmm0
movsd  %xmm0,0x678(%rbx)
movsd  0x118(%rbx),%xmm1
movsd  0x270(%rbx),%xmm0
divsd  0x260(%rbx),%xmm1
movsd  %xmm1,(%rsp)
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  (%rsp),%xmm0
divsd  0x650(%rbx),%xmm0
movsd  %xmm0,0x680(%rbx)
movsd  0x130(%rbx),%xmm2
movapd %xmm2,%xmm1
divsd  0x220(%rbx),%xmm1
mulsd  %xmm2,%xmm1
divsd  0x230(%rbx),%xmm1
divsd  0x240(%rbx),%xmm2
movsd  0x278(%rbx),%xmm0
xorpd  0x834(%rip),%xmm0
addsd  0x3dc(%rip),%xmm2
mulsd  0x460(%rbx),%xmm0
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rsp)
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  (%rsp),%xmm0
movsd  0x658(%rbx),%xmm1
addsd  0x660(%rbx),%xmm1
shufpd $0x2,0x828(%rip),%xmm0
movsd  0x650(%rbx),%xmm2
unpcklpd %xmm1,%xmm2
divpd  %xmm2,%xmm0
movupd %xmm0,0x688(%rbx)
movupd 0x2e8(%rbx),%xmm1
movsd  0x638(%rbx),%xmm7
movsd  0x648(%rbx),%xmm6
movsd  0x670(%rbx),%xmm9
movapd %xmm9,%xmm2
unpcklpd %xmm6,%xmm2
unpcklpd %xmm7,%xmm6
movupd 0x678(%rbx),%xmm4
movapd %xmm9,%xmm5
unpcklpd %xmm0,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm4,%xmm3
unpckhpd %xmm4,%xmm3
shufpd $0x2,%xmm4,%xmm7
mulpd  %xmm7,%xmm2
movapd %xmm1,%xmm7
unpckhpd %xmm1,%xmm7
unpcklpd %xmm1,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm1,%xmm6
mulpd  %xmm7,%xmm2
mulpd  %xmm5,%xmm6
addpd  %xmm2,%xmm6
movapd %xmm4,%xmm8
shufpd $0x1,%xmm0,%xmm8
unpcklpd %xmm1,%xmm0
shufpd $0x1,%xmm4,%xmm1
unpcklpd %xmm9,%xmm4
movapd %xmm6,%xmm2
unpckhpd %xmm6,%xmm2
mulsd  %xmm2,%xmm9
mulsd  %xmm6,%xmm3
addsd  %xmm6,%xmm2
shufpd $0x1,%xmm6,%xmm6
movupd %xmm6,0x698(%rbx)
mulpd  %xmm0,%xmm1
mulpd  %xmm8,%xmm4
mulpd  %xmm7,%xmm4
mulpd  %xmm5,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm1,%xmm0
movapd %xmm1,%xmm4
shufpd $0x1,%xmm1,%xmm4
movupd %xmm4,0x6a8(%rbx)
movsd  0x29f(%rip),%xmm4
subsd  0x280(%rbx),%xmm4
mulsd  0x248(%rbx),%xmm4
unpckhpd %xmm1,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  %xmm9,%xmm3
mulsd  %xmm4,%xmm3
divsd  %xmm0,%xmm3
movsd  %xmm3,0x6b8(%rbx)
movsd  0x478(%rbx),%xmm0
addsd  0x5b0(%rbx),%xmm0
addsd  0x5f0(%rbx),%xmm0
addsd  0x588(%rbx),%xmm0
addsd  0x630(%rbx),%xmm0
addsd  %xmm3,%xmm0
addsd  0x4a0(%rbx),%xmm0
addsd  0x530(%rbx),%xmm0
addsd  0x560(%rbx),%xmm0
addsd  0x610(%rbx),%xmm0
addsd  0x4f0(%rbx),%xmm0
movsd  %xmm0,0x6c0(%rbx)
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

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

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