void computeRates(double voi, double *states, double *rates,
                  double *variables) {
  variables[97] =
      variables[2] - (variables[2] - variables[3]) /
                         (1.0 + pow(variables[0] / states[4], variables[1]));
  variables[99] = variables[4] * variables[97];
  variables[98] = variables[6] / variables[97];
  rates[0] = variables[5] * states[3] - variables[99] * states[30] * states[0] -
             (variables[98] * pow(states[30], 2.0) * states[0] -
              variables[7] * states[1]);
  rates[1] =
      variables[98] * pow(states[30], 2.0) * states[0] -
      variables[7] * states[1] -
      (variables[99] * states[30] * states[1] - variables[5] * states[2]);
  rates[2] = variables[99] * states[30] * states[1] - variables[5] * states[2] -
             (variables[7] * states[2] -
              variables[98] * pow(states[30], 2.0) * states[3]);
  rates[3] =
      variables[7] * states[2] -
      variables[98] * pow(states[30], 2.0) * states[3] -
      (variables[5] * states[3] - variables[99] * states[30] * states[0]);
  variables[105] = (states[13] - states[4]) / variables[28];
  variables[95] = variables[8] * states[1] * (states[4] - states[30]);
  variables[111] = variables[20] * states[4] * (1.0 - states[11]) -
                   variables[15] * states[11];
  rates[4] = variables[105] - (variables[95] + variables[10] * variables[111]);
  variables[131] = variables[54] / (variables[54] + states[30]);
  variables[132] = 0.001 * variables[131] / variables[55];
  rates[5] = (variables[131] - states[5]) / variables[132];
  variables[106] = variables[21] * states[12] * (1.0 - states[6]) -
                   variables[16] * states[6];
  rates[6] = variables[106];
  variables[107] =
      variables[22] * states[12] * (1.0 - (states[7] + states[8])) -
      variables[17] * states[7];
  rates[7] = variables[107];
  variables[108] =
      variables[23] * variables[11] * (1.0 - (states[7] + states[8])) -
      variables[18] * states[8];
  rates[8] = variables[108];
  variables[109] = variables[19] * states[12] * (1.0 - states[9]) -
                   variables[14] * states[9];
  rates[9] = variables[109];
  variables[110] = variables[19] * states[30] * (1.0 - states[10]) -
                   variables[14] * states[10];
  rates[10] = variables[110];
  rates[11] = variables[111];
  variables[103] = (states[30] - states[12]) / variables[27];
  variables[104] = variables[102] /
                   (1.0 + exp((-states[12] + variables[24]) / variables[26]));
  rates[12] =
      1.0 *
          (variables[103] * variables[113] - variables[104] * variables[116]) /
          variables[115] -
      (variables[9] * variables[109] + variables[12] * variables[106] +
       variables[13] * variables[107]);
  rates[13] = variables[104] - variables[105] * variables[114] / variables[116];
  variables[118] =
      ((voi > variables[49]) && (voi < variables[49] + variables[50]))
          ? variables[48]
          : variables[47];
  variables[140] = (variables[43] >= 1.0) ? variables[118] : states[31];
  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[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;
  rates[14] = (variables[145] - states[14]) / variables[144];
  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]);
  rates[15] = (variables[149] - states[15]) / variables[153];
  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]);
  rates[16] = (variables[154] - states[16]) / variables[157];
  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)));
  rates[17] = (variables[170] - states[17]) / variables[171];
  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));
  rates[18] = (variables[173] - states[18]) / variables[174];
  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];
  rates[19] = (variables[175] - states[19]) / variables[176];
  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);
  rates[20] = (variables[178] - states[20]) / variables[179];
  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);
  rates[21] = (variables[180] - states[21]) / variables[181];
  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));
  rates[22] = (variables[185] - states[22]) / variables[186];
  variables[187] =
      1.0 / (30.0 * exp(variables[140] / 10.0) + exp(-variables[140] / 12.0));
  rates[23] = (variables[185] - states[23]) / variables[187];
  variables[189] = 1.0 / (1.0 + exp((variables[140] + 28.6) / 17.1));
  variables[188] = 1.0 / (100.0 * exp(-variables[140] / 54.645) +
                          656.0 * exp(variables[140] / 106.157));
  rates[24] = (variables[189] - states[24]) / variables[188];
  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]);
  rates[25] = (variables[196] - states[25]) / variables[197];
  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;
  rates[26] = (variables[159] - states[26]) / variables[160];
  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;
  rates[27] = (variables[161] - states[27]) / variables[162];
  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[205] = 1.0 / (variables[192] + variables[193]);
  rates[28] = (variables[191] - states[28]) / variables[205];
  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[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[169] = (variables[140] == -1.8) ? -1.80001 : variables[140];
  variables[204] = 0.01143 * (variables[169] + 1.8) /
                   (exp((variables[169] + 1.8) / 2.5) - 1.0);
  variables[210] = 0.001 / (variables[203] + variables[204]);
  rates[29] = (variables[167] - states[29]) / variables[210];
  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[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[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[208] = variables[35] / variables[76] *
                   exp(variables[78] * variables[140] / variables[117]) /
                   variables[202];
  variables[91] = states[32];
  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[206] = states[30] / variables[74] *
                   exp(-variables[77] * variables[140] / variables[117]) /
                   variables[200];
  variables[93] = variables[91] / (variables[71] + variables[91]);
  variables[201] = exp(variables[79] * variables[140] / (2.0 * variables[117]));
  variables[199] =
      exp(-variables[79] * variables[140] / (2.0 * variables[117]));
  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[212] =
      variables[201] * variables[93] * (variables[207] + variables[206]) +
      variables[199] * variables[206] * (variables[94] + variables[201]);
  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[211] =
      variables[199] * variables[94] * (variables[209] + variables[208]) +
      variables[208] * variables[201] * (variables[93] + variables[199]);
  variables[214] =
      variables[209] * variables[94] * (variables[207] + variables[206]) +
      variables[207] * variables[208] * (variables[94] + variables[201]);
  variables[213] =
      variables[207] * variables[93] * (variables[209] + variables[208]) +
      variables[206] * variables[209] * (variables[93] + variables[199]);
  variables[215] =
      (1.0 - variables[80]) * variables[73] *
      (variables[212] * variables[208] - variables[211] * variables[206]) /
      (variables[211] + variables[212] + variables[213] + variables[214]);
  rates[30] = variables[95] * variables[114] / variables[113] -
              ((variables[163] + variables[172] - 2.0 * variables[215]) /
                   (2.0 * variables[40] * variables[113]) +
               variables[103] + variables[9] * variables[110]);
  variables[137] = variables[117] * log(variables[38] / variables[91]);
  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[158] = variables[64] * states[26] * states[27] *
                   (variables[140] - variables[138]);
  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[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[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[166] = (variables[163] + variables[164] + variables[165]) *
                   (1.0 - variables[128]) * 1.0 * variables[127];
  variables[126] = variables[117] * log((variables[38] + 0.12 * variables[37]) /
                                        (variables[91] + 0.12 * variables[36]));
  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[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[177] = variables[90] * (variables[140] - variables[138]) *
                   states[20] * states[21];
  variables[134] = variables[117] * log((variables[37] + 0.12 * variables[38]) /
                                        (variables[36] + 0.12 * variables[91]));
  variables[190] =
      variables[133] * (variables[140] - variables[134]) * pow(states[28], 2.0);
  variables[182] = variables[62] * (variables[140] - variables[138]) *
                   (0.9 * states[23] + 0.1 * states[22]) * states[24];
  variables[216] = variables[143] + variables[182] + variables[190] +
                   variables[177] + variables[198] + variables[215] +
                   variables[148] + variables[166] + variables[172] +
                   variables[194] + variables[158];
  rates[31] = -variables[216] / variables[39];
  rates[32] = (1.0 - variables[44]) * -1.0 *
              (variables[148] + variables[141] + variables[165] +
               3.0 * variables[198] + 3.0 * variables[215]) /
              (1.0 * (variables[115] + variables[113]) * variables[40]);
}


x86 assembly (clang, -O0):
<computeRates>:
push   %rbp
mov    %rsp,%rbp
sub    $0x270,%rsp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
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  -0x88(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x80(%rbp),%xmm0
movsd  0x3e45(%rip),%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x308(%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    -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  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x318(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0xf0(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x310(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  0x3d80(%rip),%xmm1
call   1050 <pow@plt>
movsd  -0x78(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
mulsd  %xmm2,%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x310(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  0x3d00(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%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  0x318(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0xf0(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x318(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xf0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x310(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  0x3bbf(%rip),%xmm1
call   1050 <pow@plt>
movsd  -0x60(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm3
movaps %xmm0,%xmm4
movsd  -0x48(%rbp),%xmm0
mulsd  %xmm4,%xmm2
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x310(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  0x3b29(%rip),%xmm1
call   1050 <pow@plt>
movsd  -0x40(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm2
movaps %xmm0,%xmm3
movsd  -0x30(%rbp),%xmm0
mulsd  %xmm3,%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%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  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x318(%rax),%xmm2
mov    -0x10(%rbp),%rax
mulsd  0xf0(%rax),%xmm2
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x18(%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  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    -0x20(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x39f6(%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  0x348(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2f8(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x378(%rax),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x20(%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  0x393a(%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  0x418(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x28(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x420(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x20(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38c7(%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  0x350(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x30(%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  0x383e(%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  0x358(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x38(%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  0x37b6(%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  0x360(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x20(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x373c(%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  0x368(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x20(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xf0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x36c1(%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  0x370(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x20(%rbp),%rax
movsd  0x378(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x58(%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,-0x28(%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  -0x28(%rbp),%xmm0
movsd  0x35ca(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x340(%rax)
mov    -0x20(%rbp),%rax
movsd  0x338(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x388(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x340(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x3a0(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x355f(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x398(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x48(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x368(%rax),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x60(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x350(%rax),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movsd  0x68(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x358(%rax),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x60(%rax)
mov    -0x20(%rbp),%rax
movsd  0x340(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x348(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x390(%rax),%xmm1
mov    -0x20(%rbp),%rax
divsd  0x3a0(%rax),%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x8(%rbp),%xmm0
mov    -0x20(%rbp),%rax
ucomisd 0x188(%rax),%xmm0
jbe    1ba1 <computeRates+0xa61>
movsd  -0x8(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x190(%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ba1 <computeRates+0xa61>
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1bb5 <computeRates+0xa75>
mov    -0x20(%rbp),%rax
movsd  0x178(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x158(%rax),%xmm0
movsd  0x3423(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1c00 <computeRates+0xac0>
mov    -0x20(%rbp),%rax
movsd  0x3b0(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1c14 <computeRates+0xad4>
mov    -0x10(%rbp),%rax
movsd  0xf8(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x460(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x33d8(%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    1cfe <computeRates+0xbbe>
mov    -0x20(%rbp),%rax
movsd  0x33bb(%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  0x337f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x332b(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x3357(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x3343(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1d6d <computeRates+0xc2d>
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  0x32db(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x32bf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x488(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3303(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x32e3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x32c3(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x3293(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x31ef(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x324b(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x322b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x320b(%rip),%xmm1
addsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e8(%rax),%xmm1
movsd  0x31db(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xb0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x3147(%rip),%xmm2
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  0x3133(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x318f(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x480(%rax)
mov    -0x20(%rbp),%rax
movsd  0x488(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x480(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x70(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3141(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x3112(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x30a9(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x309d(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4a8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x30d1(%rip),%xmm0
addsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4b0(%rax),%xmm1
movaps 0x342a(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x2a0(%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1fd5 <computeRates+0xe95>
movsd  0x30e8(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    202d <computeRates+0xeed>
mov    -0x20(%rbp),%rax
movsd  0x30c7(%rip),%xmm0
mulsd  0x4b0(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x30a3(%rip),%xmm0
mulsd  0x4b0(%rax),%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0x2fe3(%rip),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4b8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x32c3(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x32ab(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x328f(%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  0x2f5f(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4c8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4a8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x78(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x4c8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3211(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x31f9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2ef8(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2eec(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4d0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3148(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x31a8(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x318c(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4d8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3108(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2f20(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x3144(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x2e60(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x2f04(%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  0x2e24(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4e8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4d0(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x80(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x4e8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x80(%rax)
mov    -0x20(%rbp),%rax
movsd  0x30a8(%rip),%xmm0
addsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x1c8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x3080(%rip),%xmm1
addsd  0x1c0(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2d9f(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2d93(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x550(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3037(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2e77(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x2d6b(%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  0x2fdf(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x2fdb(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x2d1f(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x558(%rax)
mov    -0x20(%rbp),%rax
movsd  0x550(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x88(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x558(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x88(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2f6b(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2f4c(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2c93(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2c87(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x568(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2f0b(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2ddb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2ede(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2d97(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x100(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x2e93(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x2e87(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2be7(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x570(%rax)
mov    -0x20(%rbp),%rax
movsd  0x568(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x90(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x570(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x90(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2e23(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2e0b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2b72(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2b66(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x578(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2dc2(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2da3(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2d7e(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2d66(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xf8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x2d42(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x2d36(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2abe(%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  0x578(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x98(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x580(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x98(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2cc6(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2cae(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2a45(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2a39(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x590(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2c6d(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2c55(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2c30(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2a60(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0xf0(%rbp),%xmm0
ff
movsd  0x2bfc(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x2be8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x2bd0(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x2bbc(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x2ba8(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x598(%rax)
mov    -0x20(%rbp),%rax
movsd  0x590(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xa0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x598(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xa0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2b4c(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2b21(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2908(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x28fc(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5a0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2ae0(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2ac8(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2aa3(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2a8b(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0xe8(%rbp),%xmm0
ff
movsd  0x2a67(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x2a53(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x2a3b(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x2a27(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x2a13(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5a8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x5a0(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xa8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x5a8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xa8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x29bf(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2990(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x27cf(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x27c3(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5c8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2947(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2903(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xe0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x28df(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x28cb(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x28b3(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5d0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x5c8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xb0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x5d0(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xb0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x27e7(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x27d3(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xd8(%rbp),%xmm1
ff
movsd  0x2802(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2672(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5d8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x5c8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xb8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x5d8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xb8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x279e(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2786(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2605(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x25f9(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5e8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2726(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x26f9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xd0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x26d5(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x2631(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2561(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5e0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x5e8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xc0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x5e0(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xc0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x25fd(%rip),%xmm1
addsd  0x460(%rax),%xmm1
movsd  0x2655(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2601(%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  0x248d(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x628(%rax)
mov    -0x20(%rbp),%rax
movsd  0x620(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xc8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x628(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xc8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2589(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2571(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2420(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2414(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4f8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x24c8(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2520(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x23d7(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x24fb(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x24e7(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x500(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4f8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xd0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x500(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xd0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2493(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x2473(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2352(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2346(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x508(%rax)
mov    -0x20(%rbp),%rax
movsd  0x2442(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x242a(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2309(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2405(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x23f1(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x510(%rax)
mov    -0x20(%rbp),%rax
movsd  0x508(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xd8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x510(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xd8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x239d(%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  0x2362(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2261(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2255(%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  0x2314(%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  0x22dd(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x21ec(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x22b8(%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  0x2280(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2255(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2179(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x608(%rax)
mov    -0x20(%rbp),%rax
movsd  0x600(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x608(%rax),%xmm1
movsd  0x2149(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x668(%rax)
mov    -0x20(%rbp),%rax
movsd  0x5f8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xe0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x668(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xe0(%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  0x216e(%rip),%xmm2
divsd  %xmm2,%xmm3
movsd  0x20a2(%rip),%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2089(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x207d(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x538(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2111(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2fcc <computeRates+0x1e8c>
jp     2fcc <computeRates+0x1e8c>
movsd  0x2369(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    3068 <computeRates+0x1f28>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2ffb <computeRates+0x1ebb>
jp     2ffb <computeRates+0x1ebb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    3058 <computeRates+0x1f18>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2309(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3034 <computeRates+0x1ef4>
jp     3034 <computeRates+0x1ef4>
movsd  0x22f9(%rip),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
jmp    3048 <computeRates+0x1f08>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x540(%rax)
mov    -0x20(%rbp),%rax
movsd  0x22d0(%rip),%xmm1
addsd  0x540(%rax),%xmm1
movsd  0x22c8(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x22a8(%rip),%xmm0
addsd  0x540(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2279(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
movsd  0x1f0d(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2231(%rip),%xmm1
addsd  0x540(%rax),%xmm1
movsd  0x2229(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2209(%rip),%xmm0
addsd  0x540(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x21da(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x128(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x120(%rbp),%xmm0
ff
movsd  0x1e7e(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x658(%rax)
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
movsd  0x2182(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    31d3 <computeRates+0x2093>
jp     31d3 <computeRates+0x2093>
movsd  0x21a2(%rip),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
jmp    31e7 <computeRates+0x20a7>
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  0x2179(%rip),%xmm1
addsd  0x548(%rax),%xmm1
movsd  0x2171(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2151(%rip),%xmm0
addsd  0x548(%rax),%xmm0
movsd  0x2111(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  0x1da5(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x660(%rax)
mov    -0x20(%rbp),%rax
movsd  0x658(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x660(%rax),%xmm1
movsd  0x1d79(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x690(%rax)
mov    -0x20(%rbp),%rax
movsd  0x538(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0xe8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x690(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xe8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1d35(%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,-0x1b8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x2047(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1cd3(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x1c0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  0x1c93(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x1fac(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x1b0(%rbp),%xmm1
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1a0(%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  0x1bc0(%rip),%xmm0
mulsd  0x1d0(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x1eec(%rip),%xmm0
mulsd  0x460(%rax),%xmm0
movsd  0x1b74(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x198(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x190(%rbp),%xmm0
ff
movsd  0x1b34(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x1e5c(%rip),%xmm0
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x188(%rbp),%xmm1
ff
movsd  -0x180(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x178(%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  0x118(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x260(%rax),%xmm0
movsd  %xmm0,-0x170(%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  -0x170(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1a15(%rip),%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm1
movsd  0x1a05(%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  0x19b1(%rip),%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x19a1(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x650(%rax)
mov    -0x20(%rbp),%rax
movsd  0x118(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x260(%rax),%xmm0
movsd  %xmm0,-0x168(%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  -0x168(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x650(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x680(%rax)
mov    -0x10(%rbp),%rax
movsd  0x100(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x2d8(%rax)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x250(%rax),%xmm0
movsd  %xmm0,-0x160(%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  -0x160(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x188e(%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  0x1862(%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  0x180e(%rip),%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x17fe(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x640(%rax)
mov    -0x10(%rbp),%rax
movsd  0xf0(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x250(%rax),%xmm0
movsd  %xmm0,-0x158(%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  -0x158(%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
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  0x278(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1717(%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  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  0x16bf(%rip),%xmm1
mulsd  0x3a8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x638(%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  0x1642(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x278(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x161e(%rip),%xmm1
mulsd  0x3a8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x150(%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  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  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  0x150e(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%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  0x14d3(%rip),%xmm1
mulsd  0x3a8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x148(%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  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  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  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  0x1317(%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  0x2f8(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x390(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x388(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x518(%rax),%xmm2
mov    -0x20(%rbp),%rax
addsd  0x560(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x6b8(%rax),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movsd  0x1224(%rip),%xmm1
mulsd  0x140(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x388(%rax),%xmm1
divsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
addsd  0x338(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xf0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x2d8(%rax),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x140(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x448(%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  0x113a(%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  0x10e5(%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  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  0x168(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    4051 <computeRates+0x2f11>
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,-0x1d8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x12dc(%rip),%xmm0
addsd  0x460(%rax),%xmm0
movsd  0x12cc(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  0xfd0(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0xc8(%rax),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
jmp    4061 <computeRates+0x2f21>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
jmp    4061 <computeRates+0x2f21>
movsd  -0x1d0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x610(%rax)
mov    -0x20(%rbp),%rax
movsd  0x133f(%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,-0x260(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x12a1(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x268(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x260(%rbp),%xmm0
ff
movsd  0xef9(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2d8(%rax),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x121a(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x258(%rbp),%xmm1
ff
movsd  -0x250(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x248(%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  0x11ce(%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,-0x238(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x1138(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x240(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x238(%rbp),%xmm0
ff
movsd  0xd90(%rip),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x120(%rax),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x128(%rax),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x10b1(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3a8(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x230(%rbp),%xmm1
ff
movsd  -0x228(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x220(%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  0x518(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x520(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x528(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0xc89(%rip),%xmm1
subsd  0x400(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc75(%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  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x128(%rax),%xmm0
movsd  0xfbd(%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  0xf95(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x218(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3f0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x208(%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  0xc8c(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x210(%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,-0x208(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  0xc1f(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x208(%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  0x2e0(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x298(%rax),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x288(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x128(%rax),%xmm0
movsd  0xe4f(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xa8f(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0xdfb(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x200(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x290(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x2d8(%rax),%xmm0
movsd  0xdef(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xa37(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0xda3(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1f8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x448(%rax),%xmm0
movsd  0xd8f(%rip),%xmm1
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xcac(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x9b8(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0xd24(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x630(%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  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x128(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x130(%rax),%xmm0
movsd  0xca4(%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  0xc7c(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x430(%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,-0x1e0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xe0(%rax),%xmm0
movsd  0x884(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1e0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5f0(%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  0x894(%rip),%xmm2
mulsd  0xb0(%rax),%xmm2
movsd  0xb94(%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  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)
mov    -0x20(%rbp),%rax
movsd  0x6c0(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
divsd  0x138(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xf8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x709(%rip),%xmm0
subsd  0x160(%rax),%xmm0
movsd  0xa71(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x4a0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x468(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x528(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x630(%rax),%xmm2
movsd  0x79d(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movsd  0x6b8(%rax),%xmm1
movsd  0x781(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x398(%rax),%xmm2
mov    -0x20(%rbp),%rax
addsd  0x388(%rax),%xmm2
movsd  0x675(%rip),%xmm1
mulsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x140(%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x100(%rax)
add    $0x270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeRates>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,0x10(%rsp)
subsd  0x18(%rdx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  (%rdx),%xmm0
movsd  0x8(%rdx),%xmm1
divsd  0x20(%rdi),%xmm0
call   1050 <pow@plt>
movsd  0x2e77(%rip),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm6
movsd  0x18(%rsp),%xmm2
divsd  %xmm0,%xmm2
movsd  0x10(%rsp),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,0x308(%rbx)
movsd  0x20(%rbx),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
movsd  %xmm0,0x318(%rbx)
movsd  0x28(%rbx),%xmm1
movsd  0x30(%rbx),%xmm2
divsd  %xmm3,%xmm2
movsd  %xmm2,0x310(%rbx)
movsd  0xf0(%r15),%xmm3
mulsd  %xmm3,%xmm0
movsd  (%r15),%xmm4
movsd  0x8(%r15),%xmm5
mulsd  %xmm4,%xmm0
mulsd  0x18(%r15),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm3
mulsd  %xmm2,%xmm3
mulsd  0x38(%rbx),%xmm5
mulsd  %xmm4,%xmm3
subsd  %xmm5,%xmm3
subsd  %xmm3,%xmm1
movsd  %xmm1,(%r14)
movsd  0xf0(%r15),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x310(%rbx),%xmm1
movsd  0x8(%r15),%xmm2
movsd  0x10(%r15),%xmm3
movsd  0x38(%rbx),%xmm4
mulsd  %xmm2,%xmm4
mulsd  (%r15),%xmm1
mulsd  0x318(%rbx),%xmm0
subsd  %xmm4,%xmm1
mulsd  0x28(%rbx),%xmm3
mulsd  %xmm2,%xmm0
subsd  %xmm3,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14)
movsd  0x10(%r15),%xmm0
movsd  0xf0(%r15),%xmm1
movsd  0x318(%rbx),%xmm2
mulsd  %xmm1,%xmm2
movsd  0x28(%rbx),%xmm3
mulsd  %xmm0,%xmm3
mulsd  0x8(%r15),%xmm2
mulsd  %xmm1,%xmm1
mulsd  0x310(%rbx),%xmm1
mulsd  0x18(%r15),%xmm1
subsd  %xmm3,%xmm2
mulsd  0x38(%rbx),%xmm0
subsd  %xmm1,%xmm0
subsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%r14)
movsd  0x38(%rbx),%xmm0
movsd  0x18(%r15),%xmm1
movsd  0xf0(%r15),%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm2,%xmm3
mulsd  0x310(%rbx),%xmm3
mulsd  %xmm1,%xmm3
mulsd  0x10(%r15),%xmm0
subsd  %xmm3,%xmm0
mulsd  0x318(%rbx),%xmm2
mulsd  (%r15),%xmm2
mulsd  0x28(%rbx),%xmm1
subsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%r14)
movsd  0x68(%r15),%xmm0
subsd  0x20(%r15),%xmm0
divsd  0xe0(%rbx),%xmm0
movsd  %xmm0,0x348(%rbx)
movsd  0x40(%rbx),%xmm1
movsd  0xa0(%rbx),%xmm2
mulsd  0x8(%r15),%xmm1
movsd  0x20(%r15),%xmm3
subsd  0xf0(%r15),%xmm3
mulsd  %xmm1,%xmm3
movsd  %xmm3,0x2f8(%rbx)
mulsd  0x20(%r15),%xmm2
movsd  0x58(%r15),%xmm1
movapd %xmm6,%xmm4
subsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm4
mulsd  0x78(%rbx),%xmm1
subsd  %xmm1,%xmm4
movsd  %xmm4,0x378(%rbx)
mulsd  0x50(%rbx),%xmm4
addsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
movsd  %xmm0,0x20(%r14)
movsd  0x1b0(%rbx),%xmm0
movsd  0xf0(%r15),%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x418(%rbx)
movsd  0x2c42(%rip),%xmm1
mulsd  %xmm0,%xmm1
divsd  0x1b8(%rbx),%xmm1
movsd  %xmm1,0x420(%rbx)
subsd  0x28(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%r14)
movsd  0xa8(%rbx),%xmm0
mulsd  0x60(%r15),%xmm0
movsd  0x30(%r15),%xmm1
movapd %xmm6,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x80(%rbx),%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x350(%rbx)
movsd  %xmm2,0x30(%r14)
movsd  0xb0(%rbx),%xmm0
mulsd  0x60(%r15),%xmm0
movsd  0x38(%r15),%xmm1
movsd  0x40(%r15),%xmm2
addsd  %xmm1,%xmm2
movapd %xmm6,%xmm3
subsd  %xmm2,%xmm3
mulsd  0x88(%rbx),%xmm1
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x358(%rbx)
movsd  %xmm3,0x38(%r14)
movsd  0xb8(%rbx),%xmm0
mulsd  0x58(%rbx),%xmm0
movsd  0x40(%r15),%xmm1
movsd  0x38(%r15),%xmm2
addsd  %xmm1,%xmm2
movapd %xmm6,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
mulsd  0x90(%rbx),%xmm1
subsd  %xmm1,%xmm3
movsd  %xmm3,0x360(%rbx)
movsd  %xmm3,0x40(%r14)
movsd  0x98(%rbx),%xmm0
mulsd  0x60(%r15),%xmm0
movsd  0x48(%r15),%xmm1
movapd %xmm6,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x70(%rbx),%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x368(%rbx)
movsd  %xmm2,0x48(%r14)
movsd  0x98(%rbx),%xmm0
mulsd  0xf0(%r15),%xmm0
movsd  0x50(%r15),%xmm1
movapd %xmm6,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x70(%rbx),%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x370(%rbx)
movsd  %xmm2,0x50(%r14)
movsd  0x378(%rbx),%xmm0
movsd  %xmm0,0x58(%r14)
movsd  0xf0(%r15),%xmm0
subsd  0x60(%r15),%xmm0
divsd  0xd8(%rbx),%xmm0
movsd  %xmm0,0x338(%rbx)
movsd  0x330(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0xc0(%rbx),%xmm0
subsd  0x60(%r15),%xmm0
divsd  0xd0(%rbx),%xmm0
call   1030 <exp@plt>
movsd  0x2a86(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x340(%rbx)
movsd  0x338(%rbx),%xmm0
mulsd  0x3a0(%rbx),%xmm1
mulsd  0x388(%rbx),%xmm0
subsd  %xmm1,%xmm0
divsd  0x398(%rbx),%xmm0
movsd  0x48(%rbx),%xmm1
movsd  0x60(%rbx),%xmm2
mulsd  0x350(%rbx),%xmm2
mulsd  0x368(%rbx),%xmm1
addsd  %xmm2,%xmm1
movsd  0x68(%rbx),%xmm2
mulsd  0x358(%rbx),%xmm2
addsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,0x60(%r14)
movsd  0x348(%rbx),%xmm0
mulsd  0x390(%rbx),%xmm0
movsd  0x340(%rbx),%xmm1
divsd  0x3a0(%rbx),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x68(%r14)
movsd  0x8(%rsp),%xmm1
movsd  0x188(%rbx),%xmm0
ucomisd %xmm0,%xmm1
jbe    163e <computeRates+0x4fe>
addsd  0x190(%rbx),%xmm0
mov    $0x30,%eax
ucomisd %xmm1,%xmm0
ja     1643 <computeRates+0x503>
mov    $0x2f,%eax
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x3b0(%rbx)
movsd  0x158(%rbx),%xmm1
ucomisd 0x29a0(%rip),%xmm1
jae    166b <computeRates+0x52b>
movsd  0xf8(%r15),%xmm0
movsd  %xmm0,0x460(%rbx)
movsd  0x2c8(%rbx),%xmm1
movsd  0x3e0(%rbx),%xmm2
movsd  0x2985(%rip),%xmm4
subsd  %xmm2,%xmm4
movsd  0x3e8(%rbx),%xmm3
subsd  %xmm3,%xmm4
subsd  %xmm1,%xmm4
xorpd  0x2d59(%rip),%xmm4
ucomisd %xmm0,%xmm4
jbe    16f0 <computeRates+0x5b0>
addsd  0x2973(%rip),%xmm0
subsd  %xmm2,%xmm0
subsd  %xmm3,%xmm0
subsd  %xmm1,%xmm0
divsd  0x2967(%rip),%xmm0
call   1030 <exp@plt>
movapd %xmm0,%xmm1
addsd  0x2926(%rip),%xmm1
movsd  0x2956(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x2952(%rip),%xmm0
jmp    1711 <computeRates+0x5d1>
subsd  %xmm2,%xmm0
subsd  %xmm3,%xmm0
subsd  %xmm1,%xmm0
divsd  0x2914(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x290f(%rip),%xmm0
movsd  %xmm0,0x488(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x291f(%rip),%xmm0
subsd  0x3e0(%rbx),%xmm0
subsd  0x3e8(%rbx),%xmm0
movsd  0x290f(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0x2905(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x2900(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x460(%rbx),%xmm0
addsd  0x28e8(%rip),%xmm0
subsd  0x3e0(%rbx),%xmm0
subsd  0x3e8(%rbx),%xmm0
movsd  0x28d8(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mulsd  0x28ce(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x2849(%rip),%xmm2
movapd %xmm2,%xmm1
subsd  %xmm0,%xmm1
movsd  0x10(%rsp),%xmm0
divsd  %xmm1,%xmm0
addsd  0x8(%rsp),%xmm0
movapd %xmm0,%xmm1
movapd %xmm2,%xmm0
divsd  %xmm1,%xmm0
addsd  0x289d(%rip),%xmm0
movsd  %xmm0,0x480(%rbx)
movsd  0x488(%rbx),%xmm1
subsd  0x70(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x70(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x2875(%rip),%xmm0
divsd  0x2875(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x27d8(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4a8(%rbx)
movsd  0x2a0(%rbx),%xmm2
movsd  0x460(%rbx),%xmm0
movsd  0x2848(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x4b0(%rbx)
movapd 0x2bac(%rip),%xmm3
andpd  %xmm1,%xmm3
movsd  0x2830(%rip),%xmm4
ucomisd %xmm3,%xmm2
ja     18b7 <computeRates+0x777>
movsd  0x282a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  0x2820(%rip),%xmm1
movapd %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm4
movsd  0x2759(%rip),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm4
movsd  0x460(%rbx),%xmm0
movsd  %xmm4,0x4b8(%rbx)
addsd  0x27f1(%rip),%xmm0
mulsd  0x27f1(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x27ec(%rip),%xmm0
movsd  %xmm0,0x4c0(%rbx)
addsd  0x4b8(%rbx),%xmm0
movsd  0x270c(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4c8(%rbx)
movsd  0x4a8(%rbx),%xmm0
subsd  0x78(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x78(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x27a8(%rip),%xmm0
divsd  0x27a8(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x26c3(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4d0(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2783(%rip),%xmm0
mulsd  0x2783(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x277e(%rip),%xmm0
movsd  %xmm0,0x4d8(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2756(%rip),%xmm0
mulsd  0x271e(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x2759(%rip),%xmm0
movsd  0x2659(%rip),%xmm2
addsd  %xmm2,%xmm0
movsd  0x26ed(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4e0(%rbx)
addsd  0x4d8(%rbx),%xmm1
movapd %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x4e8(%rbx)
movsd  0x4d0(%rbx),%xmm1
subsd  0x80(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x80(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x26fb(%rip),%xmm0
addsd  0x1c8(%rbx),%xmm0
movsd  0x1c0(%rbx),%xmm1
addsd  0x26eb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x25d2(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x550(%rbx)
movsd  0x460(%rbx),%xmm1
addsd  0x26c2(%rip),%xmm1
divsd  0x26c2(%rip),%xmm1
movapd 0x29a2(%rip),%xmm0
xorpd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x26ad(%rip),%xmm0
addsd  0x26ad(%rip),%xmm0
mulsd  0x2585(%rip),%xmm0
movsd  %xmm0,0x558(%rbx)
movsd  0x550(%rbx),%xmm1
subsd  0x88(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x88(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x2677(%rip),%xmm0
divsd  0x2677(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x2532(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x568(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2642(%rip),%xmm0
divsd  0x264a(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x2627(%rip),%xmm0
addsd  0x460(%rbx),%xmm0
divsd  0x262f(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x262a(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  0x24c8(%rip),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x570(%rbx)
movsd  0x568(%rbx),%xmm1
subsd  0x90(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x90(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x25de(%rip),%xmm0
divsd  0x25de(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x2471(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x578(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2531(%rip),%xmm0
divsd  0x25b1(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x2516(%rip),%xmm0
addsd  0x460(%rbx),%xmm0
divsd  0x2596(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x2591(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  0x23ff(%rip),%xmm0
divsd  %xmm2,%xmm0
addsd  0x1d8(%rbx),%xmm0
movsd  %xmm0,0x580(%rbx)
movsd  0x578(%rbx),%xmm1
subsd  0x98(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x98(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x253d(%rip),%xmm0
divsd  0x253d(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x23a8(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x590(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2518(%rip),%xmm0
mulsd  0x2518(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x460(%rbx),%xmm0
addsd  0x2505(%rip),%xmm0
mulsd  0x23cd(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x24f8(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x24f2(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x24ee(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x24ea(%rip),%xmm0
mulsd  0x24ea(%rip),%xmm0
movsd  %xmm0,0x598(%rbx)
movsd  0x590(%rbx),%xmm1
subsd  0xa0(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xa0(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x24bc(%rip),%xmm0
divsd  0x24bc(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x22d7(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x5a0(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2497(%rip),%xmm0
mulsd  0x2497(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x460(%rbx),%xmm0
addsd  0x2484(%rip),%xmm0
mulsd  0x2484(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x247f(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x2479(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2475(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x2471(%rip),%xmm0
mulsd  0x2471(%rip),%xmm0
movsd  %xmm0,0x5a8(%rbx)
movsd  0x5a0(%rbx),%xmm1
subsd  0xa8(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xa8(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x2443(%rip),%xmm0
divsd  0x2443(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x2206(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x5c8(%rbx)
movsd  0x460(%rbx),%xmm0
divsd  0x241e(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0x240b(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x2406(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x2400(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x23fc(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5d0(%rbx)
movsd  0x5c8(%rbx),%xmm1
subsd  0xb0(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xb0(%r14)
movsd  0x460(%rbx),%xmm0
divsd  0x2282(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0x23af(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x227c(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2130(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5d8(%rbx)
movsd  0x5c8(%rbx),%xmm1
subsd  0xb8(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xb8(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x235e(%rip),%xmm0
divsd  0x235e(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x20e1(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x5e8(%rbx)
movsd  0x460(%rbx),%xmm0
divsd  0x2339(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x460(%rbx),%xmm0
divsd  0x2326(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x2321(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x231b(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x207f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5e0(%rbx)
movsd  0x5e8(%rbx),%xmm1
subsd  0xc0(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xc0(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x22dd(%rip),%xmm0
mulsd  0x22dd(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x2148(%rip),%xmm0
movsd  %xmm0,0x618(%rbx)
movsd  0x440(%rbx),%xmm1
addsd  %xmm1,%xmm0
shufpd $0x2,0x2433(%rip),%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x620(%rbx)
movsd  0xc8(%r15),%xmm0
movapd %xmm1,%xmm2
subsd  %xmm0,%xmm2
unpckhpd %xmm1,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,0xc8(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x2279(%rip),%xmm0
divsd  0x2279(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1fbc(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4f8(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2254(%rip),%xmm0
divsd  0x2254(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1f87(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0x2243(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x223f(%rip),%xmm1
movsd  %xmm1,0x500(%rbx)
movsd  0x4f8(%rbx),%xmm0
subsd  0xd0(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0xd0(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x2211(%rip),%xmm0
divsd  0x2049(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1f24(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x508(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x21e4(%rip),%xmm0
divsd  0x2014(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1eef(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0x21cb(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x21c7(%rip),%xmm1
movsd  %xmm1,0x510(%rbx)
movsd  0x508(%rbx),%xmm0
subsd  0xd8(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0xd8(%r14)
movsd  0x460(%rbx),%xmm0
addsd  0x2199(%rip),%xmm0
subsd  0x438(%rbx),%xmm0
divsd  0x2191(%rip),%xmm0
call   1030 <exp@plt>
movapd %xmm0,%xmm1
movsd  0x1e80(%rip),%xmm0
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2198 <computeRates+0x1058>
sqrtsd %xmm0,%xmm0
jmp    219d <computeRates+0x105d>
call   1060 <sqrt@plt>
movsd  %xmm0,0x5f8(%rbx)
movsd  0x460(%rbx),%xmm0
addsd  0x2153(%rip),%xmm0
subsd  0x438(%rbx),%xmm0
divsd  0x214b(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1e2e(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0x213a(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x600(%rbx)
movsd  0x460(%rbx),%xmm0
subsd  0x438(%rbx),%xmm0
addsd  0x211e(%rip),%xmm0
divsd  0x211e(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x608(%rbx)
addsd  0x600(%rbx),%xmm0
movsd  0x1dd9(%rip),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x668(%rbx)
movsd  0x5f8(%rbx),%xmm0
subsd  0xe0(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0xe0(%r14)
movsd  0x410(%rbx),%xmm1
movsd  0x460(%rbx),%xmm0
subsd  0x1a0(%rbx),%xmm0
subsd  0x408(%rbx),%xmm0
xorpd  0x2183(%rip),%xmm0
divsd  0x200b(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  0x1a8(%rbx),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1d5e(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x538(%rbx)
movsd  0x460(%rbx),%xmm1
ucomisd 0x2076(%rip),%xmm1
jne    22d0 <computeRates+0x1190>
jp     22d0 <computeRates+0x1190>
movsd  0x2062(%rip),%xmm0
jmp    22f6 <computeRates+0x11b6>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    22dc <computeRates+0x119c>
jnp    22f6 <computeRates+0x11b6>
ucomisd 0x2064(%rip),%xmm1
jne    22f2 <computeRates+0x11b2>
jp     22f2 <computeRates+0x11b2>
movsd  0x2050(%rip),%xmm0
jmp    22f6 <computeRates+0x11b6>
movapd %xmm1,%xmm0
movsd  %xmm0,0x540(%rbx)
addsd  0x204a(%rip),%xmm0
movsd  0x204a(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
divsd  0x2040(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1d33(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x540(%rbx),%xmm0
addsd  0x201b(%rip),%xmm0
movsd  0x201b(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
divsd  0x2011(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1cec(%rip),%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x658(%rbx)
movsd  0x460(%rbx),%xmm1
movsd  0x1fe4(%rip),%xmm0
cmpeqsd %xmm1,%xmm0
movsd  0x1fdf(%rip),%xmm2
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movlpd %xmm0,0x548(%rbx)
addsd  0x1fcb(%rip),%xmm0
movsd  0x1fcb(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
divsd  0x1fc1(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1c74(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x660(%rbx)
addsd  0x658(%rbx),%xmm1
movapd %xmm1,%xmm2
movsd  0x1bf6(%rip),%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0x690(%rbx)
movsd  0x538(%rbx),%xmm0
subsd  0xe8(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0xe8(%r14)
movsd  0x198(%rbx),%xmm1
addsd  %xmm1,%xmm1
movsd  0x460(%rbx),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x3a8(%rbx),%xmm1
movsd  %xmm1,0x10(%rsp)
mulsd  0x1f38(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1b7f(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  0x8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0xf0(%r15),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x118(%rbx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x460(%rbx),%xmm0
mulsd  0x1ee0(%rip),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0xe8(%r15),%xmm1
mulsd  0x88(%r15),%xmm1
mulsd  0x28(%r15),%xmm1
movsd  %xmm1,0x518(%rbx)
movsd  0x1d0(%rbx),%xmm1
movsd  0x3a8(%rbx),%xmm2
movsd  %xmm2,0x10(%rsp)
addsd  %xmm1,%xmm1
movsd  0x460(%rbx),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0x1e69(%rip),%xmm0
divsd  %xmm2,%xmm0
call   1030 <exp@plt>
movsd  0x1ab0(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  0x8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0xf0(%r15),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x118(%rbx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x1e19(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0x90(%r15),%xmm1
mulsd  0x98(%r15),%xmm1
movsd  %xmm1,0x560(%rbx)
movsd  0x118(%rbx),%xmm1
movsd  0x270(%rbx),%xmm0
divsd  0x260(%rbx),%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
movsd  0x19f1(%rip),%xmm4
addsd  %xmm4,%xmm0
mulsd  0x8(%rsp),%xmm0
addsd  %xmm4,%xmm0
movsd  0x130(%rbx),%xmm1
movapd %xmm1,%xmm2
divsd  0x220(%rbx),%xmm2
movapd %xmm1,%xmm3
divsd  0x230(%rbx),%xmm3
movsd  0x118(%rbx),%xmm5
divsd  0x240(%rbx),%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x650(%rbx)
divsd  0x260(%rbx),%xmm5
movsd  %xmm5,0x8(%rsp)
movsd  0x270(%rbx),%xmm0
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x8(%rsp),%xmm0
divsd  0x650(%rbx),%xmm0
movsd  %xmm0,0x680(%rbx)
movsd  0x100(%r15),%xmm0
movsd  %xmm0,0x2d8(%rbx)
movsd  0xf0(%r15),%xmm0
divsd  0x250(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x268(%rbx),%xmm0
xorpd  0x1d1e(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
movsd  0x1901(%rip),%xmm4
addsd  %xmm4,%xmm0
movsd  0x2d8(%rbx),%xmm1
movapd %xmm1,%xmm2
divsd  0x258(%rbx),%xmm2
addsd  %xmm0,%xmm2
mulsd  0x8(%rsp),%xmm2
movapd %xmm1,%xmm0
divsd  0x218(%rbx),%xmm0
movapd %xmm1,%xmm3
divsd  0x228(%rbx),%xmm3
divsd  0x238(%rbx),%xmm1
addsd  %xmm4,%xmm2
addsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x640(%rbx)
movsd  0xf0(%r15),%xmm0
divsd  0x250(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x268(%rbx),%xmm0
xorpd  0x1c78(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x8(%rsp),%xmm0
divsd  0x640(%rbx),%xmm0
movsd  %xmm0,0x670(%rbx)
movsd  0x278(%rbx),%xmm0
movsd  0x2d8(%rbx),%xmm1
movsd  0x238(%rbx),%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x2e8(%rbx)
mulsd  0x460(%rbx),%xmm0
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x648(%rbx)
movsd  0x278(%rbx),%xmm0
xorpd  0x1bf0(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x638(%rbx)
movsd  0x2d8(%rbx),%xmm3
movapd %xmm3,%xmm1
divsd  0x218(%rbx),%xmm1
mulsd  %xmm3,%xmm1
divsd  0x228(%rbx),%xmm1
divsd  0x238(%rbx),%xmm3
movsd  0x278(%rbx),%xmm0
movsd  0x1793(%rip),%xmm2
addsd  %xmm2,%xmm3
mulsd  0x460(%rbx),%xmm0
mulsd  %xmm1,%xmm3
movsd  %xmm3,0x8(%rsp)
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x8(%rsp),%xmm0
divsd  0x640(%rbx),%xmm0
movsd  %xmm0,0x678(%rbx)
movsd  0x648(%rbx),%xmm1
movsd  0x2e8(%rbx),%xmm2
mulsd  %xmm1,%xmm2
movsd  0x670(%rbx),%xmm3
addsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mulsd  0x638(%rbx),%xmm3
addsd  0x2f0(%rbx),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x6a0(%rbx)
movsd  0x130(%rbx),%xmm2
movapd %xmm2,%xmm1
divsd  0x220(%rbx),%xmm1
mulsd  %xmm2,%xmm1
divsd  0x230(%rbx),%xmm1
divsd  0x240(%rbx),%xmm2
movsd  0x16de(%rip),%xmm0
addsd  %xmm0,%xmm2
movsd  0x278(%rbx),%xmm0
xorpd  0x1aca(%rip),%xmm0
mulsd  0x460(%rbx),%xmm0
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0x3a8(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x8(%rsp),%xmm0
divsd  0x650(%rbx),%xmm0
movsd  %xmm0,0x688(%rbx)
movsd  0x638(%rbx),%xmm1
movupd 0x2e8(%rbx),%xmm9
movapd %xmm9,%xmm10
unpckhpd %xmm9,%xmm10
mulsd  %xmm1,%xmm10
movsd  0x648(%rbx),%xmm8
movupd 0x678(%rbx),%xmm4
movsd  0x670(%rbx),%xmm11
movapd %xmm11,%xmm2
unpcklpd %xmm0,%xmm2
addpd  %xmm4,%xmm2
movapd %xmm4,%xmm7
unpcklpd %xmm0,%xmm7
shufpd $0x2,%xmm4,%xmm0
movapd %xmm11,%xmm6
unpcklpd %xmm4,%xmm6
unpckhpd %xmm4,%xmm4
movapd %xmm4,%xmm5
mulsd  %xmm8,%xmm5
unpcklpd %xmm8,%xmm1
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm2
mulsd  %xmm10,%xmm2
addpd  %xmm9,%xmm1
mulsd  %xmm1,%xmm5
shufpd $0x1,%xmm3,%xmm3
addsd  %xmm5,%xmm2
movsd  %xmm2,0x698(%rbx)
mulpd  %xmm9,%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm0,%xmm6
mulpd  %xmm1,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm6,0x6a8(%rbx)
movsd  0x15d2(%rip),%xmm0
subsd  0x280(%rbx),%xmm0
mulsd  0x248(%rbx),%xmm0
movsd  0x6a0(%rbx),%xmm1
mulsd  %xmm2,%xmm11
mulsd  %xmm1,%xmm4
subsd  %xmm11,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm2
addsd  %xmm6,%xmm2
unpckhpd %xmm6,%xmm6
addsd  %xmm2,%xmm6
divsd  %xmm6,%xmm4
movsd  %xmm4,0x6b8(%rbx)
movsd  0x2f8(%rbx),%xmm0
mulsd  0x390(%rbx),%xmm0
movsd  0x518(%rbx),%xmm1
addsd  0x560(%rbx),%xmm1
movsd  0x388(%rbx),%xmm2
addsd  %xmm4,%xmm4
subsd  %xmm4,%xmm1
movsd  0x48(%rbx),%xmm3
movsd  0x140(%rbx),%xmm4
addsd  %xmm4,%xmm4
mulsd  %xmm2,%xmm4
divsd  %xmm4,%xmm1
addsd  0x338(%rbx),%xmm1
mulsd  0x370(%rbx),%xmm3
divsd  %xmm2,%xmm0
addsd  %xmm1,%xmm3
subsd  %xmm3,%xmm0
movsd  %xmm0,0xf0(%r14)
movsd  0x3a8(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x130(%rbx),%xmm0
divsd  0x2d8(%rbx),%xmm0
call   1040 <log@plt>
movapd %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x448(%rbx)
movsd  0x70(%r15),%xmm2
mulsd  0x3d0(%rbx),%xmm2
movsd  0x460(%rbx),%xmm0
movapd %xmm0,%xmm3
subsd  %xmm1,%xmm3
movsd  0x14c3(%rip),%xmm1
subsd  0x2b8(%rbx),%xmm1
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
movsd  %xmm3,0x468(%rbx)
movsd  0x70(%r15),%xmm2
mulsd  0x3d8(%rbx),%xmm2
movapd %xmm0,%xmm4
subsd  0x450(%rbx),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x470(%rbx)
addsd  %xmm3,%xmm2
movsd  %xmm2,0x478(%rbx)
movsd  0x200(%rbx),%xmm1
mulsd  0xd0(%r15),%xmm1
movsd  0x168(%rbx),%xmm2
mulsd  0xd8(%r15),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,0x4f0(%rbx)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
jbe    2c15 <computeRates+0x1ad5>
movsd  0x1e0(%rbx),%xmm1
mulsd  0x1e8(%rbx),%xmm1
mulsd  %xmm1,%xmm4
movsd  %xmm4,0x8(%rsp)
movsd  0x150b(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movapd %xmm0,%xmm1
addsd  0x1402(%rip),%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0xc8(%r15),%xmm1
movsd  0x460(%rbx),%xmm0
movsd  %xmm1,0x610(%rbx)
movsd  0x198(%rbx),%xmm1
mulsd  0x1783(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x3a8(%rbx),%xmm2
movsd  %xmm2,0x10(%rsp)
movapd 0x17b3(%rip),%xmm1
xorpd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
call   1030 <exp@plt>
movsd  0x139e(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  0x8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x130(%rbx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x2d8(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x460(%rbx),%xmm0
xorpd  0x1758(%rip),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0xe8(%r15),%xmm1
mulsd  0x88(%r15),%xmm1
mulsd  0x28(%r15),%xmm1
movsd  %xmm1,0x528(%rbx)
movsd  0x198(%rbx),%xmm1
mulsd  0x16bd(%rip),%xmm1
movsd  0x460(%rbx),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x3a8(%rbx),%xmm1
movsd  %xmm1,0x10(%rsp)
xorpd  0x16dd(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x12cc(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  0x8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x120(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x128(%rbx),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x460(%rbx),%xmm0
xorpd  0x1686(%rip),%xmm0
divsd  0x3a8(%rbx),%xmm0
call   1030 <exp@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
mulsd  0xe8(%r15),%xmm1
mulsd  0x88(%r15),%xmm1
mulsd  0x28(%r15),%xmm1
movsd  %xmm1,0x520(%rbx)
addsd  0x518(%rbx),%xmm1
addsd  0x528(%rbx),%xmm1
movsd  0x122b(%rip),%xmm0
subsd  0x400(%rbx),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x3f8(%rbx),%xmm0
movsd  %xmm0,0x530(%rbx)
movsd  0x3a8(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x15b9(%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  0x8(%rsp),%xmm0
movsd  %xmm0,0x3f0(%rbx)
movsd  0x208(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x78(%r15),%xmm0
movsd  0x1566(%rip),%xmm1
call   1050 <pow@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x80(%r15),%xmm0
movsd  0x460(%rbx),%xmm1
subsd  0x3f0(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x490(%rbx)
movsd  0x210(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x78(%r15),%xmm0
movsd  0x151a(%rip),%xmm1
call   1050 <pow@plt>
mulsd  0x8(%rsp),%xmm0
movsd  0x460(%rbx),%xmm1
subsd  0x3f0(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x498(%rbx)
addsd  0x490(%rbx),%xmm1
movsd  %xmm1,0x4a0(%rbx)
movsd  0x288(%rbx),%xmm0
movsd  0x2e0(%rbx),%xmm1
mulsd  0x298(%rbx),%xmm1
movsd  %xmm1,0x8(%rsp)
divsd  0x128(%rbx),%xmm0
movsd  0x14bd(%rip),%xmm1
call   1050 <pow@plt>
movsd  0x10e0(%rip),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
mulsd  0x8(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0x290(%rbx),%xmm0
divsd  0x2d8(%rbx),%xmm0
movsd  0x1488(%rip),%xmm1
call   1050 <pow@plt>
movsd  0x10a3(%rip),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
mulsd  0x8(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0x460(%rbx),%xmm0
subsd  0x448(%rbx),%xmm0
addsd  0x1453(%rip),%xmm0
divsd  0x1453(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x105e(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x630(%rbx)
movsd  0x460(%rbx),%xmm0
subsd  0x450(%rbx),%xmm0
mulsd  0x2d0(%rbx),%xmm0
mulsd  0xa0(%r15),%xmm0
mulsd  0xa8(%r15),%xmm0
movsd  0x3a8(%rbx),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,0x588(%rbx)
movsd  0x130(%rbx),%xmm0
movsd  0x13b8(%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  0x8(%rsp),%xmm0
movsd  %xmm0,0x430(%rbx)
movsd  0x460(%rbx),%xmm1
movapd %xmm1,%xmm2
subsd  %xmm0,%xmm2
mulsd  0x428(%rbx),%xmm2
movsd  0xe0(%r15),%xmm3
mulsd  %xmm3,%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x5f0(%rbx)
subsd  0x450(%rbx),%xmm1
mulsd  0x1f0(%rbx),%xmm1
movsd  0xb0(%r15),%xmm2
movsd  0xb8(%r15),%xmm0
mulsd  0xfda(%rip),%xmm2
mulsd  0x1352(%rip),%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
mulsd  0xc0(%r15),%xmm0
movsd  %xmm0,0x5b0(%rbx)
addsd  0x478(%rbx),%xmm0
addsd  %xmm3,%xmm0
addsd  0x588(%rbx),%xmm0
addsd  0x630(%rbx),%xmm0
addsd  0x6b8(%rbx),%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)
movapd 0x12ed(%rip),%xmm1
xorpd  %xmm1,%xmm0
divsd  0x138(%rbx),%xmm0
movsd  %xmm0,0xf8(%r14)
movsd  0xed0(%rip),%xmm0
subsd  0x160(%rbx),%xmm0
xorpd  %xmm1,%xmm0
movapd %xmm0,%xmm4
movsd  0x4a0(%rbx),%xmm0
addsd  0x468(%rbx),%xmm0
movsd  0x398(%rbx),%xmm1
addsd  0x528(%rbx),%xmm0
movsd  0x630(%rbx),%xmm2
movsd  0x1258(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
mulsd  0x6b8(%rbx),%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm4,%xmm3
addsd  0x388(%rbx),%xmm1
mulsd  0x140(%rbx),%xmm1
divsd  %xmm1,%xmm3
movsd  %xmm3,0x100(%r14)
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

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