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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double exp(double);
double pow(double, double);
void computeRates(double voi, double *states, double *rates,
                  double *variables) {
  variables[126] =
      (variables[56] == 0.0)
          ? pow(1.0 / (1.0 + exp(-states[14] / 5.46)), 1.0 / 3.0)
          : pow(1.0 / (1.0 + exp(-(states[14] + 30.32) / 5.46)), 1.0 / 3.0);
  variables[127] =
      (variables[56] == 0.0)
          ? 0.0006247 / (0.832 * exp(-0.335 * (states[14] + 56.7)) +
                         0.627 * exp(0.082 * (states[14] + 65.01))) +
                4.0e-5
          : 0.0006247 / (0.8322166 * exp(-0.33566 * (states[14] + 56.7062)) +
                         0.6274 * exp(0.0823 * (states[14] + 65.0131))) +
                4.569e-5;
  rates[0] = (variables[126] - states[0]) / variables[127];
  variables[130] = 1.0 / (1.0 + exp((states[14] + 66.1) / 6.4));
  variables[132] = 3.717e-6 * exp(-0.2815 * (states[14] + 17.11)) /
                       (1.0 + 0.003732 * exp(-0.3426 * (states[14] + 37.76))) +
                   0.0005977;
  rates[1] = (variables[130] - states[1]) / variables[132];
  variables[131] = variables[130];
  variables[133] = 3.186e-8 * exp(-0.6219 * (states[14] + 18.8)) /
                       (1.0 + 7.189e-5 * exp(-0.6683 * (states[14] + 34.07))) +
                   0.003556;
  rates[2] = (variables[131] - states[2]) / variables[133];
  variables[139] =
      (variables[56] == 0.0) ? 1.0 / (1.0 + exp(-(states[14] + 23.1) / 6.0))
      : (variables[56] == 1.0)
          ? 1.0 / (1.0 + exp(-(states[14] + 22.3 + 0.8 * variables[110]) / 6.0))
          : 1.0 / (1.0 + exp(-(states[14] + 22.2) / 6.0));
  variables[136] =
      (variables[56] == 0.0)
          ? -28.38 * (states[14] + 35.0) /
                    (exp(-(states[14] + 35.0) / 2.5) - 1.0) -
                84.9 * states[14] / (exp(-0.208 * states[14]) - 1.0)
      : (variables[56] == 1.0)
          ? -28.39 * (states[14] + 35.0) /
                    (exp(-(states[14] + 35.0) / 2.5) - 1.0) -
                84.9 * states[14] / (exp(-0.208 * states[14]) - 1.0)
          : -28.4 * (states[14] + 35.0) /
                    (exp(-(states[14] + 35.0) / 2.5) - 1.0) -
                84.9 * states[14] / (exp(-0.208 * states[14]) - 1.0);
  variables[137] =
      (variables[56] == 1.0)
          ? 11.43 * (states[14] - 5.0) / (exp(0.4 * (states[14] - 5.0)) - 1.0)
          : 11.42 * (states[14] - 5.0) / (exp(0.4 * (states[14] - 5.0)) - 1.0);
  variables[138] = 2.0 / (variables[136] + variables[137]);
  rates[3] = (variables[139] - states[3]) / variables[138];
  variables[143] = 1.0 / (1.0 + exp((states[14] + 45.0) / 5.0));
  variables[140] =
      (variables[56] == 1.0)
          ? 3.75 * (states[14] + 28.0) / (exp((states[14] + 28.0) / 4.0) - 1.0)
          : 3.12 * (states[14] + 28.0) / (exp((states[14] + 28.0) / 4.0) - 1.0);
  variables[141] = (variables[56] == 1.0)
                       ? 30.0 / (1.0 + exp(-(states[14] + 28.0) / 4.0))
                       : 25.0 / (1.0 + exp(-(states[14] + 28.0) / 4.0));
  variables[142] =
      (variables[56] == 1.0)
          ? (1.2 - 0.2 * variables[110]) / (variables[140] + variables[141])
          : 1.0 / (variables[140] + variables[141]);
  rates[4] = (variables[143] - states[4]) / variables[142];
  variables[149] = 1.0 / (1.0 + exp(-(states[14] + 37.0) / 6.8));
  variables[146] = 1068.0 * exp((states[14] + 26.3) / 30.0);
  variables[147] = 1068.0 * exp(-(states[14] + 26.3) / 30.0);
  variables[148] = 1.0 / (variables[146] + variables[147]);
  rates[5] = (variables[149] - states[5]) / variables[148];
  variables[153] = 1.0 / (1.0 + exp((states[14] + 71.0) / 9.0));
  variables[150] =
      (variables[56] == 1.0)
          ? 15.3 * exp(-(states[14] + 71.0 + 0.7 * variables[110]) / 83.3)
          : 15.3 * exp(-(states[14] + 71.7) / 83.3);
  variables[151] = (variables[56] == 1.0)
                       ? 15.0 * exp((states[14] + 71.0) / 15.38)
                       : 15.0 * exp((states[14] + 71.7) / 15.38);
  variables[152] = 1.0 / (variables[150] + variables[151]);
  rates[6] = (variables[153] - states[6]) / variables[152];
  variables[158] = 1.0 / (1.0 + exp((states[14] + 59.37) / 13.1));
  variables[159] =
      (variables[56] == 0.0)
          ? 0.0101 + 0.06517 / (0.57 * exp(-0.08 * (states[14] + 49.0))) +
                2.4e-5 * exp(0.1 * (states[14] + 50.93))
      : (variables[56] == 1.0)
          ? 0.001 / 3.0 *
                (30.31 +
                 195.5 /
                     (0.5686 * exp(-0.08161 * (states[14] + 39.0 +
                                               10.0 * variables[110])) +
                      0.7174 *
                          exp((0.2719 - 0.1719 * variables[110]) * 1.0 *
                              (states[14] + 40.93 + 10.0 * variables[110]))))
          : 0.0101 + 0.06517 / (0.5686 * exp(-0.08161 * (states[14] + 39.0)) +
                                0.7174 * exp(0.2719 * (states[14] + 40.93)));
  rates[7] = (variables[158] - states[7]) / variables[159];
  variables[160] = 1.0 / (1.0 + exp(-(states[14] - 10.93) / 19.7));
  variables[161] =
      (variables[56] == 0.0)
          ? 0.001 * (2.98 + 15.59 / (1.037 * exp(0.09 * (states[14] + 30.61)) +
                                     0.369 * exp(-0.12 * (states[14] + 23.84))))
      : (variables[56] == 1.0)
          ? 0.0025 *
                (1.191 + 7.838 / (1.037 * exp(0.09012 * (states[14] + 30.61)) +
                                  0.369 * exp(-0.119 * (states[14] + 23.84))))
          : 0.001 *
                (2.98 + 19.59 / (1.037 * exp(0.09012 * (states[14] + 30.61)) +
                                 0.369 * exp(-0.119 * (states[14] + 23.84))));
  rates[8] = (variables[160] - states[8]) / variables[161];
  variables[164] = (variables[56] != 2.0)
                       ? 1.0 / (1.0 + exp(-(states[14] + 14.2) / 10.6))
                       : 1.0 / (1.0 + exp(-(states[14] + 13.2) / 10.6));
  variables[165] = (variables[56] != 2.0)
                       ? 1.0 / (37.2 * exp((states[14] - 9.0) / 15.9) +
                                0.96 * exp(-(states[14] - 9.0) / 22.5))
                       : 1.0 / (37.2 * exp((states[14] - 10.0) / 15.9) +
                                0.96 * exp(-(states[14] - 10.0) / 22.5));
  rates[9] = (variables[164] - states[9]) / variables[165];
  variables[166] = variables[164];
  variables[167] = (variables[56] != 2.0)
                       ? 1.0 / (4.2 * exp((states[14] - 9.0) / 17.0) +
                                0.15 * exp(-(states[14] - 9.0) / 21.6))
                       : 1.0 / (4.2 * exp((states[14] - 10.0) / 17.0) +
                                0.15 * exp(-(states[14] - 10.0) / 21.6));
  rates[10] = (variables[166] - states[10]) / variables[167];
  variables[169] = 1.0 / (1.0 + exp((states[14] + 18.6) / 10.1));
  rates[11] = (variables[169] - states[11]) / variables[168];
  variables[172] = 14.0 / (1.0 + exp(-(states[14] - 40.0) / 9.0));
  variables[173] = 1.0 * exp(-states[14] / 45.0);
  rates[12] = variables[172] * (1.0 - states[12]) - variables[173] * states[12];
  variables[178] = (variables[56] == 0.0)
                       ? 1.0 * exp(-(states[14] + 78.91) / 26.62)
                       : 1.0 * exp(-(states[14] + 78.91) / 26.63);
  variables[179] = 1.0 * exp((states[14] + 75.13) / 21.25);
  rates[13] = variables[178] * (1.0 - states[13]) - variables[179] * states[13];
  variables[118] = variables[117] *
                   pow(variables[48] / (variables[103] + variables[48]), 3.0) *
                   pow(variables[47] / (variables[102] + variables[47]), 2.0) *
                   1.6 / (1.5 + exp(-(states[14] + 60.0) / 40.0));
  variables[116] =
      (variables[56] == 0.0)
          ? variables[115] *
                (pow(variables[48], 3.0) * variables[45] *
                     exp(0.03743 * states[14] * variables[89]) -
                 pow(variables[49], 3.0) * variables[44] *
                     exp(0.0374 * states[14] * (variables[89] - 1.0))) /
                (1.0 +
                 variables[88] * (variables[44] * pow(variables[49], 3.0) +
                                  variables[45] * pow(variables[48], 3.0)))
          : variables[115] *
                (pow(variables[48], 3.0) * variables[45] *
                     exp(0.03743 * states[14] * variables[89]) -
                 pow(variables[49], 3.0) * variables[44] *
                     exp(0.03743 * states[14] * (variables[89] - 1.0))) /
                (1.0 +
                 variables[88] * (variables[44] * pow(variables[49], 3.0) +
                                  variables[45] * pow(variables[48], 3.0)));
  variables[177] =
      (variables[56] != 2.0)
          ? variables[176] * states[13] * (states[14] - variables[122])
          : variables[176] * states[13] * (states[14] + 102.0);
  variables[175] =
      (variables[56] != 2.0)
          ? variables[174] * states[13] * (states[14] - variables[121])
          : variables[174] * states[13] * (states[14] - 77.6);
  variables[171] =
      variables[170] * pow(states[12], 2.0) * (states[14] - variables[124]);
  variables[157] = variables[155] * states[8] * (states[14] - variables[122]);
  variables[156] =
      variables[154] * states[7] * states[8] * (states[14] - variables[122]);
  variables[145] =
      variables[144] * states[5] * states[6] * (states[14] - variables[7]);
  variables[135] = variables[134] *
                   (states[4] * states[3] +
                    0.006 / (1.0 + exp(-(states[14] + 14.1) / 6.0))) *
                   (states[14] - variables[0]);
  variables[128] =
      (variables[56] == 0.0)
          ? 0.0952 * exp(-0.063 * (states[14] + 34.4)) /
                    (1.0 + 1.66 * exp(-0.225 * (states[14] + 63.7))) +
                0.0869
          : 0.09518 * exp(-0.06306 * (states[14] + 34.4)) /
                    (1.0 + 1.662 * exp(-0.2251 * (states[14] + 63.7))) +
                0.08693;
  variables[129] =
      (1.0 - variables[128]) * states[1] + variables[128] * states[2];
  variables[183] =
      variables[125] * pow(states[0], 3.0) * variables[129] * variables[49] *
      pow(variables[52], 2.0) / (variables[54] * variables[55]) *
      (exp((states[14] - variables[121]) * variables[52] /
           (variables[54] * variables[55])) -
       1.0) /
      (exp(states[14] * variables[52] / (variables[54] * variables[55])) -
       1.0) *
      states[14];
  variables[181] = variables[113] * (states[14] - variables[122]);
  variables[182] = variables[114] * (states[14] - variables[123]);
  variables[180] = variables[112] * (states[14] - variables[121]);
  variables[163] = 0.6 * states[9] + 0.4 * states[10];
  variables[184] = variables[162] * variables[163] * states[11] *
                   (states[14] - variables[122]);
  rates[14] =
      -1.0 / variables[111] *
      (variables[183] + variables[135] + variables[145] + variables[156] +
       variables[157] + variables[184] + variables[171] + variables[175] +
       variables[177] + variables[180] + variables[182] + variables[181] +
       variables[116] + variables[118] + variables[120]);
}


x86 assembly (clang, -O0):
<computeRates>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b0,%rsp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11bb <computeRates+0x9b>
jp     11bb <computeRates+0x9b>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2e8d(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2e74(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2e68(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x2e54(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x28(%rbp)
jmp    121e <computeRates+0xfe>
mov    -0x10(%rbp),%rax
movsd  0x2e51(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2e25(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2e0c(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2e00(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x2dec(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3f0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12dd <computeRates+0x1bd>
jp     12dd <computeRates+0x1bd>
mov    -0x10(%rbp),%rax
movsd  0x2e36(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2e21(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2dff(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2dea(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x38(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  0x2dc9(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x2db5(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2d65(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x2d91(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    1367 <computeRates+0x247>
mov    -0x10(%rbp),%rax
movsd  0x2d6f(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2d5a(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2d38(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2d23(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x40(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  0x2d02(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x2cee(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2cd6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x2cc2(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3f8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3f0(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x3f8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x2d64(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x2d4f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2c3e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2c32(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x410(%rax)
mov    -0x10(%rbp),%rax
movsd  0x2d0e(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2cf9(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2cdd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2cc0(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2cab(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  0x2c8a(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x2bae(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0x2c66(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x420(%rax)
mov    -0x20(%rbp),%rax
movsd  0x410(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x420(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x410(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x418(%rax)
mov    -0x10(%rbp),%rax
movsd  0x2c00(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2beb(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2bcf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2bb2(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2b9d(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  0x2b7c(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x2ad8(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0x2b58(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x428(%rax)
mov    -0x20(%rbp),%rax
movsd  0x418(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x428(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15f4 <computeRates+0x4d4>
jp     15f4 <computeRates+0x4d4>
mov    -0x10(%rbp),%rax
movsd  0x2b93(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2b4f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2a2e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2a22(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    16ef <computeRates+0x5cf>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x2a00(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    168f <computeRates+0x56f>
jp     168f <computeRates+0x56f>
mov    -0x10(%rbp),%rax
movsd  0x2b0c(%rip),%xmm1
addsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x2aeb(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2ab4(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2993(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2987(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    16e5 <computeRates+0x5c5>
mov    -0x10(%rbp),%rax
movsd  0x2a85(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2a59(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2938(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x292c(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x458(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17ee <computeRates+0x6ce>
jp     17ee <computeRates+0x6ce>
mov    -0x10(%rbp),%rax
movsd  0x2a2d(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2a38(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2a0b(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x29df(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  0x287e(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x29a5(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2987(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x78(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
movsd  0x2830(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19e2 <computeRates+0x8c2>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x2806(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    18f6 <computeRates+0x7d6>
jp     18f6 <computeRates+0x7d6>
mov    -0x10(%rbp),%rax
movsd  0x293a(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x293d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2915(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x28e9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x2785(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x28a9(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2888(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x98(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x90(%rbp),%xmm0
ff
movsd  0x272b(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    19d5 <computeRates+0x8b5>
mov    -0x10(%rbp),%rax
movsd  0x2856(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2851(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2831(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2805(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x26a1(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x27c5(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x27a4(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0xb0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x2647(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x440(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x2601(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1a8e <computeRates+0x96e>
jp     1a8e <computeRates+0x96e>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x2758(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x275c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x272f(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x271b(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0x258f(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1b00 <computeRates+0x9e0>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x26e1(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x26dd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x26b8(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x26a4(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  0x2518(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x448(%rax)
mov    -0x20(%rbp),%rax
movsd  0x440(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x448(%rax),%xmm1
movsd  0x266c(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x450(%rax)
mov    -0x20(%rbp),%rax
movsd  0x458(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x18(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x450(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
movsd  0x261e(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x25f9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2470(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2464(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x478(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x2440(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1c47 <computeRates+0xb27>
jp     1c47 <computeRates+0xb27>
mov    -0x10(%rbp),%rax
movsd  0x25cc(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x25cf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x25a7(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x2592(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  0x23d6(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1cb1 <computeRates+0xb91>
mov    -0x10(%rbp),%rax
movsd  0x255d(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2558(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2538(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x2523(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
movsd  0x2367(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x460(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x232f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1d47 <computeRates+0xc27>
jp     1d47 <computeRates+0xc27>
mov    -0x10(%rbp),%rax
movsd  0x24bb(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x248f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x22de(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x249a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    1da0 <computeRates+0xc80>
mov    -0x10(%rbp),%rax
movsd  0x245d(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2431(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2280(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2434(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x468(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x2240(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1e25 <computeRates+0xd05>
jp     1e25 <computeRates+0xd05>
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x23ec(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x23e8(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x468(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1e51 <computeRates+0xd31>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x468(%rax),%xmm1
movsd  0x21c3(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x470(%rax)
mov    -0x20(%rbp),%rax
movsd  0x478(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x470(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movsd  0x2375(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2349(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2138(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x212c(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4a8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x2308(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x22cb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x22df(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x490(%rax)
mov    -0x10(%rbp),%rax
movsd  0x22cb(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2277(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x228b(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x498(%rax)
mov    -0x20(%rbp),%rax
movsd  0x490(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x498(%rax),%xmm1
movsd  0x206b(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4a0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4a8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x28(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x4a0(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x10(%rbp),%rax
movsd  0x220d(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x21f8(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2007(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1ffb(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4c8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1fd7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    20b2 <computeRates+0xf92>
jp     20b2 <computeRates+0xf92>
mov    -0x10(%rbp),%rax
movsd  0x21a3(%rip),%xmm1
addsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x21ca(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2193(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2177(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    2102 <computeRates+0xfe2>
mov    -0x10(%rbp),%rax
movsd  0x216a(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x213e(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2122(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1ede(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2178 <computeRates+0x1058>
jp     2178 <computeRates+0x1058>
mov    -0x10(%rbp),%rax
movsd  0x20aa(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x20ed(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x20d1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    21b1 <computeRates+0x1091>
mov    -0x10(%rbp),%rax
movsd  0x20a4(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x20af(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2093(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4b8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4b0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x4b8(%rax),%xmm1
movsd  0x1e23(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4c0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4c8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x30(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x4c0(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x10(%rbp),%rax
movsd  0x2025(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x2010(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1dbf(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1db3(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4f0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    231c <computeRates+0x11fc>
jp     231c <computeRates+0x11fc>
mov    -0x10(%rbp),%rax
movsd  0x2058(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2043(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2027(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1fa3(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x1f8f(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1fef(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1fda(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x118(%rbp),%xmm1
ff
movsd  0x1fb9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    24e7 <computeRates+0x13c7>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1cd8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2444 <computeRates+0x1324>
jp     2444 <computeRates+0x1324>
mov    -0x10(%rbp),%rax
movsd  0x1f44(%rip),%xmm0
addsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm1
movsd  0x1f4b(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1f13(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x1f1e(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1ed2(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0x1c56(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x1ebe(%rip),%xmm2
addsd  0x70(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm1
movsd  0x1ed5(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x128(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1e71(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1e5d(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1e8d(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x1e79(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1e65(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    24d7 <computeRates+0x13b7>
mov    -0x10(%rbp),%rax
movsd  0x1e40(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1e2b(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1e06(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1df1(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x130(%rbp),%xmm0
ff
movsd  0x1dcd(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1db9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1da1(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x1d8d(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4f8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4f0(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x38(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x4f8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x1dc2(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1d97(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1a9e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1a92(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x500(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2649 <computeRates+0x1529>
jp     2649 <computeRates+0x1529>
mov    -0x10(%rbp),%rax
movsd  0x1d8f(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1db2(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1d55(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1d80(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x140(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1d1c(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1d08(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1d40(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x1cdc(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1cc8(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
jmp    27c0 <computeRates+0x16a0>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x19ab(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2711 <computeRates+0x15f1>
jp     2711 <computeRates+0x15f1>
mov    -0x10(%rbp),%rax
movsd  0x1cc7(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1cb2(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1c8d(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1c78(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x150(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1c54(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1c40(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1c70(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x1c5c(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1c48(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    27b0 <computeRates+0x1690>
mov    -0x10(%rbp),%rax
movsd  0x1c23(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1c0e(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1be9(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1bd4(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x158(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1bb0(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1b9c(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1b84(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x1b70(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1b5c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x508(%rax)
mov    -0x20(%rbp),%rax
movsd  0x500(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x40(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x508(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x198e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2827 <computeRates+0x1707>
jp     2827 <computeRates+0x1707>
jmp    2885 <computeRates+0x1765>
mov    -0x10(%rbp),%rax
movsd  0x1b55(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1b21(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x17a0(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1794(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    28de <computeRates+0x17be>
mov    -0x10(%rbp),%rax
movsd  0x1aef(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1ac3(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1742(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1736(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x520(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x189a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    291b <computeRates+0x17fb>
jp     291b <computeRates+0x17fb>
jmp    29c6 <computeRates+0x18a6>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x18bc(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x1a70(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x188e(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1a23(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x170(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x19ff(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x19eb(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1653(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
jmp    2a6c <computeRates+0x194c>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x18d9(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x19c5(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x18ab(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1978(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x178(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1954(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1940(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x15a8(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x528(%rax)
mov    -0x20(%rbp),%rax
movsd  0x520(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x48(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x528(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x20(%rbp),%rax
movsd  0x520(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x530(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x16ca(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2aeb <computeRates+0x19cb>
jp     2aeb <computeRates+0x19cb>
jmp    2b96 <computeRates+0x1a76>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x16ec(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x18c0(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x16be(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1873(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x188(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x184f(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x183b(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1483(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
jmp    2c3c <computeRates+0x1b1c>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x1709(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x1815(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x16db(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x17c8(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x190(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x17a4(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1790(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x13d8(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x538(%rax)
mov    -0x20(%rbp),%rax
movsd  0x530(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x50(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x538(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x10(%rbp),%rax
movsd  0x1762(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x174d(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1364(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1358(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x548(%rax)
mov    -0x20(%rbp),%rax
movsd  0x548(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x58(%rax),%xmm0
mov    -0x20(%rbp),%rax
divsd  0x540(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x16dd(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x14ca(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x12d9(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1695(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x560(%rax)
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1425(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1281(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x568(%rax)
mov    -0x20(%rbp),%rax
movsd  0x560(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x1259(%rip),%xmm2
subsd  0x60(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x568(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x60(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2e65 <computeRates+0x1d45>
jp     2e65 <computeRates+0x1d45>
mov    -0x10(%rbp),%rax
movsd  0x15dc(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x15c0(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x11b4(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
jmp    2eb5 <computeRates+0x1d95>
mov    -0x10(%rbp),%rax
movsd  0x1587(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x155b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x115f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x590(%rax)
mov    -0x10(%rbp),%rax
movsd  0x155b(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1546(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1112(%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
movsd  0x10ea(%rip),%xmm2
subsd  0x68(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x598(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x68(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x338(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x180(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  0x147c(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1b0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x178(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x330(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x178(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  0x11b0(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1a8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x140c(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x13ec(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1390(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  0x13a4(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    3281 <computeRates+0x2161>
jp     3281 <computeRates+0x2161>
mov    -0x20(%rbp),%rax
movsd  0x398(%rax),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x1361(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x168(%rax),%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1354(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2c8(%rax),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x130a(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x160(%rax),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1305(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2c8(%rax),%xmm1
movsd  0xeb4(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x200(%rbp),%xmm2
ff
movsd  -0x1f8(%rbp),%xmm1
ff
movsd  -0x1f0(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2c0(%rax),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x160(%rax),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x1231(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x1d0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x168(%rax),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x11fc(%rip),%xmm1
call   1040 <pow@plt>
movsd  -0x1e0(%rbp),%xmm3
ff
movsd  -0x1d8(%rbp),%xmm2
ff
movsd  -0x1d0(%rbp),%xmm4
ff
movsd  -0x1c8(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x1c0(%rbp),%xmm0
ff
mulsd  %xmm5,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xd9c(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
jmp    3466 <computeRates+0x2346>
mov    -0x20(%rbp),%rax
movsd  0x398(%rax),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x1177(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x168(%rax),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x116a(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2c8(%rax),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x1120(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x160(%rax),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1113(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2c8(%rax),%xmm1
movsd  0xcca(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x248(%rbp),%xmm2
ff
movsd  -0x240(%rbp),%xmm1
ff
movsd  -0x238(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x230(%rbp),%xmm0
ff
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x2c0(%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x160(%rax),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x1047(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x168(%rax),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x1012(%rip),%xmm1
call   1040 <pow@plt>
movsd  -0x228(%rbp),%xmm3
ff
movsd  -0x220(%rbp),%xmm2
ff
movsd  -0x218(%rbp),%xmm4
ff
movsd  -0x210(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x208(%rbp),%xmm0
ff
mulsd  %xmm5,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xbb2(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3a0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xd12(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    34a3 <computeRates+0x2383>
jp     34a3 <computeRates+0x2383>
jmp    34de <computeRates+0x23be>
mov    -0x20(%rbp),%rax
movsd  0x580(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3d0(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
jmp    3510 <computeRates+0x23f0>
mov    -0x20(%rbp),%rax
movsd  0x580(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xf49(%rip),%xmm1
addsd  0x70(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x250(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x588(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xc68(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    354d <computeRates+0x242d>
jp     354d <computeRates+0x242d>
jmp    3588 <computeRates+0x2468>
mov    -0x20(%rbp),%rax
movsd  0x570(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3c8(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
jmp    35be <computeRates+0x249e>
mov    -0x20(%rbp),%rax
movsd  0x570(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0xea2(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x258(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x578(%rax)
mov    -0x20(%rbp),%rax
movsd  0x550(%rax),%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  0xba9(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x278(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3e0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x558(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4d8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3d0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4e8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x4d0(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3d0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4e0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x480(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x38(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x488(%rax)
mov    -0x20(%rbp),%rax
movsd  0x430(%rax),%xmm0
movsd  %xmm0,-0x260(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xd31(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x9c5(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x270(%rbp),%xmm1
ff
movsd  -0x268(%rbp),%xmm3
ff
movaps %xmm0,%xmm2
movsd  -0x260(%rbp),%xmm0
ff
movsd  0x889(%rip),%xmm4
addsd  %xmm2,%xmm4
movsd  0xccd(%rip),%xmm2
divsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x438(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    3876 <computeRates+0x2756>
jp     3876 <computeRates+0x2756>
mov    -0x10(%rbp),%rax
movsd  0xcb1(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0xccc(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0xcb0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xc60(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0xc83(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x288(%rbp),%xmm0
ff
movsd  0xc5f(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x7b3(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0xc3b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
jmp    390c <computeRates+0x27ec>
mov    -0x10(%rbp),%rax
movsd  0xc16(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0xc01(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0xbe5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0xbc5(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0xbb0(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x290(%rbp),%xmm0
ff
movsd  0xb8c(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x718(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0xb68(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x280(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x400(%rax)
mov    -0x20(%rbp),%rax
movsd  0x6dc(%rip),%xmm0
subsd  0x400(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x400(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x408(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3e8(%rax),%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xa96(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x2b0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x408(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x188(%rax),%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x1a0(%rax),%xmm0
movsd  0x7ce(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x2a8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1b0(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x1b8(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x3c8(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x1a0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1b0(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x1b8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x2a0(%rbp),%xmm0
ff
movsd  0x5a9(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x1a0(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x1b0(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x1b8(%rax),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x298(%rbp),%xmm0
ff
movsd  0x550(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5b8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x388(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3d0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5a8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x390(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3d8(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x380(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3c8(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5a0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x5fb(%rip),%xmm1
mulsd  0x50(%rax),%xmm1
movsd  0x946(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x518(%rax)
mov    -0x20(%rbp),%rax
movsd  0x510(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x518(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  0x3d0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x5c0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x8d8(%rip),%xmm0
divsd  0x378(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x5b8(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x438(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x488(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x4e0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x4e8(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x5c0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x558(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x578(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x588(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x5a0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x5b0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x5a8(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x3a0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x3b0(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x3c0(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x70(%rax)
add    $0x2b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeRates>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
movsd  0x70(%rdi),%xmm1
movsd  0x1ebf(%rip),%xmm2
addsd  %xmm1,%xmm2
xorpd  %xmm3,%xmm3
movsd  0x1c0(%rdx),%xmm0
cmpeqsd %xmm3,%xmm0
andpd  %xmm0,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
divsd  0x1e9e(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1e99(%rip),%xmm2
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm2
movsd  0x1e91(%rip),%xmm1
movapd %xmm2,%xmm0
call   1040 <pow@plt>
movsd  %xmm0,0x3f0(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd 0x2308(%rip),%xmm0
movsd  0x70(%r15),%xmm0
jne    120c <computeRates+0xec>
jp     120c <computeRates+0xec>
addsd  0x1e9e(%rip),%xmm0
mulsd  0x1e9e(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1e8d(%rip),%xmm0
mulsd  0x1e8d(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm2
mulsd  0x1e82(%rip),%xmm0
mulsd  0x1e82(%rip),%xmm2
addsd  %xmm0,%xmm2
movsd  0x1e7e(%rip),%xmm0
jmp    1264 <computeRates+0x144>
addsd  0x1e0c(%rip),%xmm0
mulsd  0x1e0c(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1dfb(%rip),%xmm0
mulsd  0x1dfb(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm2
mulsd  0x1df0(%rip),%xmm0
mulsd  0x1df0(%rip),%xmm2
addsd  %xmm0,%xmm2
movsd  0x1dec(%rip),%xmm0
movsd  0x1e24(%rip),%xmm1
divsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x3f8(%rbx)
movsd  0x3f0(%rbx),%xmm0
subsd  (%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x1df8(%rip),%xmm0
divsd  0x1df8(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1d5b(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x410(%rbx)
movsd  0x70(%r15),%xmm0
addsd  0x1dd5(%rip),%xmm0
mulsd  0x1dd5(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1dd0(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1dc4(%rip),%xmm0
mulsd  0x1dc4(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1dbf(%rip),%xmm0
addsd  0x1cf7(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  0x1dad(%rip),%xmm1
movsd  %xmm1,0x420(%rbx)
movsd  0x410(%rbx),%xmm0
subsd  0x8(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x410(%rbx),%xmm0
movsd  %xmm0,0x418(%rbx)
movsd  0x70(%r15),%xmm0
addsd  0x1d77(%rip),%xmm0
mulsd  0x1d77(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1d72(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1d66(%rip),%xmm0
mulsd  0x1d66(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1d61(%rip),%xmm0
addsd  0x1c61(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  0x1d4f(%rip),%xmm1
movsd  %xmm1,0x428(%rbx)
movsd  0x418(%rbx),%xmm0
subsd  0x10(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1405 <computeRates+0x2e5>
jp     1405 <computeRates+0x2e5>
movsd  0x70(%r15),%xmm0
addsd  0x1d2d(%rip),%xmm0
jmp    1441 <computeRates+0x321>
ucomisd 0x1c03(%rip),%xmm0
movsd  0x70(%r15),%xmm1
jne    1435 <computeRates+0x315>
jp     1435 <computeRates+0x315>
addsd  0x1d01(%rip),%xmm1
movsd  0x370(%rbx),%xmm0
mulsd  0x1cf9(%rip),%xmm0
addsd  %xmm1,%xmm0
jmp    1441 <computeRates+0x321>
addsd  0x1cdb(%rip),%xmm1
movapd %xmm1,%xmm0
divsd  0x1cef(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1bba(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x458(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1492 <computeRates+0x372>
jp     1492 <computeRates+0x372>
movsd  0x70(%r15),%xmm0
addsd  0x1cb8(%rip),%xmm0
movsd  0x1cc8(%rip),%xmm1
jmp    14be <computeRates+0x39e>
ucomisd 0x1b76(%rip),%xmm0
movsd  0x70(%r15),%xmm0
addsd  0x1c98(%rip),%xmm0
jne    14b6 <computeRates+0x396>
jp     14b6 <computeRates+0x396>
movsd  0x1c9c(%rip),%xmm1
jmp    14be <computeRates+0x39e>
movsd  0x1c8a(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
divsd  0x1c90(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1c8b(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x70(%r15),%xmm0
movsd  0x1c75(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mulsd  0x1c6b(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1c4e(%rip),%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x440(%rbx)
movsd  0x1c0(%rbx),%xmm0
movsd  0x1ace(%rip),%xmm1
cmpeqsd %xmm1,%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  0x70(%r15),%xmm0
addsd  0x1c23(%rip),%xmm0
lea    0x1f5c(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0x1c0d(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1be0(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x448(%rbx)
addsd  0x440(%rbx),%xmm1
movsd  0x1be6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x450(%rbx)
movsd  0x458(%rbx),%xmm1
subsd  0x18(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x1bbc(%rip),%xmm0
divsd  0x1bbc(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1a1f(%rip),%xmm2
addsd  %xmm2,%xmm0
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x478(%rbx)
movsd  0x1c0(%rbx),%xmm0
cmpeqsd %xmm2,%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  0x70(%r15),%xmm0
addsd  0x1b80(%rip),%xmm0
lea    0x1ea1(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0x1b6a(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1b15(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x460(%rbx)
movsd  0x1c0(%rbx),%xmm0
cmpeqsd 0x199a(%rip),%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
lea    0x1e5b(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x1b10(%rip),%xmm0
addsd  0x70(%r15),%xmm0
mulsd  0x1b12(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm2
movsd  0x1957(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm2
movsd  %xmm2,0x468(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd %xmm1,%xmm0
movapd %xmm1,%xmm0
jne    16f5 <computeRates+0x5d5>
jp     16f5 <computeRates+0x5d5>
movsd  0x370(%rbx),%xmm0
mulsd  0x1ad3(%rip),%xmm0
addsd  0x1ad3(%rip),%xmm0
addsd  0x460(%rbx),%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0x470(%rbx)
movsd  0x478(%rbx),%xmm1
subsd  0x20(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x1aa1(%rip),%xmm0
divsd  0x1aa1(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x18cc(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4a8(%rbx)
movsd  0x70(%r15),%xmm0
addsd  0x1a7e(%rip),%xmm0
divsd  0x1a7e(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1a79(%rip),%xmm0
movsd  %xmm0,0x490(%rbx)
movsd  0x1a59(%rip),%xmm0
addsd  0x70(%r15),%xmm0
divsd  0x1a63(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1a4e(%rip),%xmm0
movsd  %xmm0,0x498(%rbx)
addsd  0x490(%rbx),%xmm0
movsd  0x1856(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4a0(%rbx)
movsd  0x4a8(%rbx),%xmm0
subsd  0x28(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x1a14(%rip),%xmm0
divsd  0x1a14(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x180f(%rip),%xmm2
addsd  %xmm2,%xmm0
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4c8(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd %xmm2,%xmm0
movsd  0x70(%r15),%xmm1
jne    1849 <computeRates+0x729>
jp     1849 <computeRates+0x729>
addsd  0x19cd(%rip),%xmm1
movsd  0x370(%rbx),%xmm0
mulsd  0x19d5(%rip),%xmm0
addsd  %xmm1,%xmm0
jmp    1855 <computeRates+0x735>
addsd  0x19bf(%rip),%xmm1
movapd %xmm1,%xmm0
divsd  0x19c3(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x19be(%rip),%xmm0
movsd  %xmm0,0x4b0(%rbx)
movsd  0x1c0(%rbx),%xmm0
cmpeqsd 0x178d(%rip),%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  0x70(%r15),%xmm0
lea    0x1c58(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
divsd  0x198b(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1986(%rip),%xmm0
movsd  %xmm0,0x4b8(%rbx)
addsd  0x4b0(%rbx),%xmm0
movsd  0x1746(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4c0(%rbx)
movsd  0x4c8(%rbx),%xmm0
subsd  0x30(%r15),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x1944(%rip),%xmm0
divsd  0x1944(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x16ff(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4f0(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19a0 <computeRates+0x880>
jp     19a0 <computeRates+0x880>
movsd  0x70(%r15),%xmm0
addsd  0x196d(%rip),%xmm0
mulsd  0x196d(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1968(%rip),%xmm0
movsd  0x1920(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x191c(%rip),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1948(%rip),%xmm0
mulsd  0x1948(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1943(%rip),%xmm0
addsd  0x8(%rsp),%xmm0
jmp    1ac4 <computeRates+0x9a4>
ucomisd 0x1668(%rip),%xmm0
movsd  0x70(%r15),%xmm0
addsd  0x189a(%rip),%xmm0
jne    1a68 <computeRates+0x948>
jp     1a68 <computeRates+0x948>
movsd  0x370(%rbx),%xmm1
mulsd  0x18be(%rip),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x187a(%rip),%xmm1
movapd %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1865(%rip),%xmm0
movsd  0x370(%rbx),%xmm1
unpcklpd %xmm1,%xmm1
movapd 0x1af1(%rip),%xmm2
mulpd  0x1af9(%rip),%xmm1
unpcklpd %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x1838(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x1832(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1846(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1842(%rip),%xmm0
mulsd  0x1842(%rip),%xmm0
jmp    1ac4 <computeRates+0x9a4>
mulsd  0x17e8(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x17d7(%rip),%xmm0
mulsd  0x17d7(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x17d2(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x17cc(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x17c8(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x17c4(%rip),%xmm0
movsd  %xmm0,0x4f8(%rbx)
movsd  0x4f0(%rbx),%xmm1
subsd  0x38(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x17ee(%rip),%xmm0
divsd  0x17ee(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1509(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x500(%rbx)
movsd  0x1c0(%rbx),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    1ba2 <computeRates+0xa82>
jp     1ba2 <computeRates+0xa82>
movsd  0x70(%r15),%xmm0
addsd  0x17b7(%rip),%xmm0
mulsd  0x180f(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x17a6(%rip),%xmm0
mulsd  0x17f6(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x17a1(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x179b(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x17d7(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1793(%rip),%xmm0
mulsd  0x1793(%rip),%xmm0
jmp    1c34 <computeRates+0xb14>
movsd  0x70(%r15),%xmm0
addsd  0x1740(%rip),%xmm0
mulsd  0x1740(%rip),%xmm0
movsd  %xmm1,0x8(%rsp)
call   1030 <exp@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1729(%rip),%xmm0
mulsd  0x1729(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x10(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
ucomisd 0x1418(%rip),%xmm2
mulsd  0x1710(%rip),%xmm0
mulsd  0x1710(%rip),%xmm1
addsd  %xmm0,%xmm1
jne    2645 <computeRates+0x1525>
jp     2645 <computeRates+0x1525>
movsd  0x1718(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1714(%rip),%xmm0
mulsd  0x1714(%rip),%xmm0
movsd  %xmm0,0x508(%rbx)
movsd  0x500(%rbx),%xmm1
subsd  0x40(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%r14)
movsd  0x1c0(%rbx),%xmm0
movsd  0x152c(%rip),%xmm1
cmpneqsd %xmm1,%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  0x70(%r15),%xmm0
lea    0x18a2(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
divsd  0x16dd(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1378(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x520(%rbx)
movsd  0x1c0(%rbx),%xmm2
cmpneqsd 0x14d7(%rip),%xmm2
movsd  0x16af(%rip),%xmm1
movapd %xmm2,%xmm0
andpd  %xmm1,%xmm0
movsd  0x16a7(%rip),%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,0x10(%rsp)
movsd  0x70(%r15),%xmm0
addsd  %xmm2,%xmm0
divsd  0x168f(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movapd 0x10(%rsp),%xmm0
addsd  0x70(%r15),%xmm0
divsd  0x1678(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1673(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x166d(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x12d9(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x528(%rbx)
movsd  0x520(%rbx),%xmm1
subsd  0x48(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x48(%r14)
movsd  0x520(%rbx),%xmm0
movsd  %xmm0,0x530(%rbx)
movsd  0x1c0(%rbx),%xmm2
cmpneqsd 0x1414(%rip),%xmm2
movapd %xmm2,%xmm0
movsd  0x15e8(%rip),%xmm1
andpd  %xmm1,%xmm0
movsd  0x15e4(%rip),%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,0x10(%rsp)
movsd  0x70(%r15),%xmm0
addsd  %xmm2,%xmm0
divsd  0x15ec(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movapd 0x10(%rsp),%xmm0
addsd  0x70(%r15),%xmm0
divsd  0x15d5(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x15d0(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x15ca(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1216(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x538(%rbx)
movsd  0x530(%rbx),%xmm1
subsd  0x50(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x1594(%rip),%xmm0
divsd  0x1594(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x11cf(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x548(%rbx)
subsd  0x58(%r15),%xmm1
divsd  0x540(%rbx),%xmm1
movsd  %xmm1,0x58(%r14)
movsd  0x70(%r15),%xmm0
addsd  0x155d(%rip),%xmm0
movsd  0x14f5(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
addsd  0x1184(%rip),%xmm0
movsd  0x1544(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x560(%rbx)
movsd  0x70(%r15),%xmm0
divsd  0x1532(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x568(%rbx)
movsd  0x60(%r15),%xmm1
movsd  0x1147(%rip),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm1
mulsd  0x560(%rbx),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x60(%r14)
xorpd  %xmm1,%xmm1
movsd  0x1c0(%rbx),%xmm0
cmpeqsd %xmm1,%xmm0
movq   %xmm0,%rax
movsd  0x70(%r15),%xmm0
addsd  0x14e1(%rip),%xmm0
and    $0x1,%eax
lea    0x161f(%rip),%rcx
divsd  (%rcx,%rax,8),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x590(%rbx)
movsd  0x70(%r15),%xmm0
addsd  0x14bf(%rip),%xmm0
divsd  0x14bf(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x598(%rbx)
movsd  0x68(%r15),%xmm1
movsd  0x10bc(%rip),%xmm2
subsd  %xmm1,%xmm2
mulsd  0x590(%rbx),%xmm2
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x68(%r14)
movsd  0x3a8(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x180(%rbx),%xmm0
movsd  0x338(%rbx),%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
movsd  0x1464(%rip),%xmm1
call   1040 <pow@plt>
mulsd  0x8(%rsp),%xmm0
movsd  0x178(%rbx),%xmm2
movsd  0x330(%rbx),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x1439(%rip),%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x142d(%rip),%xmm0
divsd  0x13e5(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1420(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x3b0(%rbx)
xorpd  %xmm0,%xmm0
cmpeqsd 0x1c0(%rbx),%xmm0
movq   %xmm0,%r12
and    $0x1,%r12d
movsd  0x398(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x180(%rbx),%xmm0
movsd  0x13c2(%rip),%xmm1
call   1040 <pow@plt>
mulsd  0x168(%rbx),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x70(%r15),%xmm0
mulsd  0x13c1(%rip),%xmm0
mulsd  0x2c8(%rbx),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x188(%rbx),%xmm0
movsd  0x137e(%rip),%xmm1
call   1040 <pow@plt>
movsd  0x70(%r15),%xmm2
lea    0x14ac(%rip),%rax
mulsd  (%rax,%r12,8),%xmm2
movsd  0x2c8(%rbx),%xmm1
addsd  0x10be(%rip),%xmm1
mulsd  %xmm2,%xmm1
mulsd  0x160(%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
movapd %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x20(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x28(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x2c0(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x160(%rbx),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x188(%rbx),%xmm0
movsd  0x12ed(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x168(%rbx),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x180(%rbx),%xmm0
movsd  0x12c4(%rip),%xmm1
call   1040 <pow@plt>
mulsd  0x30(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x28(%rsp),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  0xeab(%rip),%xmm1
movsd  0x8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x3a0(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd 0x1009(%rip),%xmm0
movsd  0x580(%rbx),%xmm1
mulsd  0x68(%r15),%xmm1
movsd  0x70(%r15),%xmm2
jne    219f <computeRates+0x107f>
jnp    21d9 <computeRates+0x10b9>
movsd  0x3d0(%rbx),%xmm0
movsd  0x570(%rbx),%xmm3
subsd  %xmm0,%xmm2
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x588(%rbx)
mulsd  0x68(%r15),%xmm3
movsd  0x70(%r15),%xmm1
subsd  0x3c8(%rbx),%xmm1
mulsd  %xmm3,%xmm1
jmp    2215 <computeRates+0x10f5>
addsd  0x1247(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x588(%rbx)
movsd  0x3d0(%rbx),%xmm0
movsd  0x570(%rbx),%xmm2
mulsd  0x68(%r15),%xmm2
movsd  0x70(%r15),%xmm1
addsd  0x121f(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x578(%rbx)
movsd  0x60(%r15),%xmm1
movsd  0x70(%r15),%xmm2
mulsd  %xmm1,%xmm1
mulsd  0x550(%rbx),%xmm1
subsd  0x3e0(%rbx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x558(%rbx)
movsd  0x4d8(%rbx),%xmm1
mulsd  0x40(%r15),%xmm1
movsd  0x70(%r15),%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x4e8(%rbx)
movsd  0x480(%rbx),%xmm1
movsd  0x4d0(%rbx),%xmm2
mulsd  0x38(%r15),%xmm2
mulsd  0x40(%r15),%xmm2
movsd  0x70(%r15),%xmm3
subsd  %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x4e0(%rbx)
mulsd  0x28(%r15),%xmm1
mulsd  0x30(%r15),%xmm1
movsd  0x70(%r15),%xmm0
subsd  0x38(%rbx),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x488(%rbx)
movsd  0x430(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x20(%r15),%xmm1
movsd  0x70(%r15),%xmm0
addsd  0x1154(%rip),%xmm0
divsd  0xe4c(%rip),%xmm0
mulsd  0x18(%r15),%xmm1
movsd  %xmm1,0x10(%rsp)
call   1030 <exp@plt>
addsd  0xd0b(%rip),%xmm0
movsd  0x1133(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x10(%rsp),%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  0x70(%r15),%xmm0
subsd  (%rbx),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x438(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movsd  0x70(%r15),%xmm0
addsd  0x10f7(%rip),%xmm0
jne    23af <computeRates+0x128f>
jp     23af <computeRates+0x128f>
mulsd  0x1123(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x111e(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x10e2(%rip),%xmm0
mulsd  0x110a(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x10ff(%rip),%xmm0
addsd  0xc6f(%rip),%xmm0
divsd  %xmm0,%xmm1
addsd  0x10f3(%rip),%xmm1
jmp    2407 <computeRates+0x12e7>
mulsd  0x1099(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1094(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r15),%xmm0
addsd  0x1088(%rip),%xmm0
mulsd  0x1088(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x107d(%rip),%xmm0
addsd  0xc15(%rip),%xmm0
divsd  %xmm0,%xmm1
addsd  0x1071(%rip),%xmm1
movsd  %xmm1,0x400(%rbx)
movsd  0xbf9(%rip),%xmm0
subsd  %xmm1,%xmm0
mulsd  0x10(%r15),%xmm1
mulsd  0x8(%r15),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x408(%rbx)
movsd  0x3e8(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
movsd  0xfb2(%rip),%xmm1
call   1040 <pow@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x408(%rbx),%xmm0
mulsd  0x188(%rbx),%xmm0
movsd  0x1a0(%rbx),%xmm2
movsd  0x70(%r15),%xmm1
subsd  0x3c8(%rbx),%xmm1
movsd  0x1b0(%rbx),%xmm3
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x1b8(%rbx),%xmm3
divsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rsp)
divsd  %xmm3,%xmm1
movapd %xmm1,%xmm0
call   1030 <exp@plt>
movapd %xmm0,%xmm1
movsd  0xcaa(%rip),%xmm0
addsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x70(%r15),%xmm0
mulsd  0x1a0(%rbx),%xmm0
movsd  0x1b0(%rbx),%xmm1
mulsd  0x1b8(%rbx),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0xc6b(%rip),%xmm6
addsd  %xmm6,%xmm0
movsd  0x8(%rsp),%xmm7
divsd  %xmm0,%xmm7
mulsd  0x70(%r15),%xmm7
movsd  %xmm7,0x5b8(%rbx)
movsd  0x70(%r15),%xmm0
movsd  0x3d0(%rbx),%xmm3
subsd  %xmm3,%xmm0
mulsd  0x388(%rbx),%xmm0
movsd  %xmm0,0x5a8(%rbx)
movsd  0x70(%r15),%xmm1
subsd  0x3d8(%rbx),%xmm1
mulsd  0x390(%rbx),%xmm1
movsd  %xmm1,0x5b0(%rbx)
movsd  0x70(%r15),%xmm2
subsd  0x3c8(%rbx),%xmm2
mulsd  0x380(%rbx),%xmm2
movsd  %xmm2,0x5a0(%rbx)
movsd  0x48(%r15),%xmm4
movsd  0x50(%r15),%xmm5
mulsd  0xbfd(%rip),%xmm5
mulsd  0xf15(%rip),%xmm4
addsd  %xmm5,%xmm4
movsd  %xmm4,0x518(%rbx)
mulsd  0x510(%rbx),%xmm4
mulsd  0x58(%r15),%xmm4
movsd  0x70(%r15),%xmm5
subsd  %xmm3,%xmm5
mulsd  %xmm4,%xmm5
movsd  %xmm5,0x5c0(%rbx)
divsd  0x378(%rbx),%xmm6
movapd %xmm7,%xmm3
addsd  0x438(%rbx),%xmm3
addsd  0x488(%rbx),%xmm3
addsd  0x4e0(%rbx),%xmm3
addsd  0x4e8(%rbx),%xmm3
addsd  %xmm5,%xmm3
addsd  0x558(%rbx),%xmm3
addsd  0x578(%rbx),%xmm3
addsd  0x588(%rbx),%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
addsd  0x3a0(%rbx),%xmm3
addsd  0x3b0(%rbx),%xmm3
addsd  0x3c0(%rbx),%xmm3
mulsd  %xmm6,%xmm3
movsd  %xmm3,0x70(%r14)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
movsd  0xcd3(%rip),%xmm0
jmp    1b89 <computeRates+0xa69>

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 56
%11 = load double, double* %10
%12 = fcmp oeq double %11, 0.000000e+00
br i1 %12, label %13, label %23
13: ; preds = %4
%14 = load double*, double** %6
%15 = getelementptr inbounds double, double* %14, i64 14
%16 = load double, double* %15
%17 = fneg double %16
%18 = fdiv double %17, 5.460000e+00
%19 = call double @exp(double %18)
%20 = fadd double 1.000000e+00, %19
%21 = fdiv double 1.000000e+00, %20
%22 = call double @pow(double %21, double 0x3FD5555555555555)
br label %34
23: ; preds = %4
%24 = load double*, double** %6
%25 = getelementptr inbounds double, double* %24, i64 14
%26 = load double, double* %25
%27 = fadd double %26, 3.032000e+01
%28 = fneg double %27
%29 = fdiv double %28, 5.460000e+00
%30 = call double @exp(double %29)
%31 = fadd double 1.000000e+00, %30
%32 = fdiv double 1.000000e+00, %31
%33 = call double @pow(double %32, double 0x3FD5555555555555)
br label %34
34: ; preds = %23, %13
%35 = phi double [ %22, %13 ], [ %33, %23 ]
%36 = load double*, double** %8
%37 = getelementptr inbounds double, double* %36, i64 126
store double %35, double* %37
%38 = load double*, double** %8
%39 = getelementptr inbounds double, double* %38, i64 56
%40 = load double, double* %39
%41 = fcmp oeq double %40, 0.000000e+00
br i1 %41, label %42, label %59
42: ; preds = %34
%43 = load double*, double** %6
%44 = getelementptr inbounds double, double* %43, i64 14
%45 = load double, double* %44
%46 = fadd double %45, 5.670000e+01
%47 = fmul double -3.350000e-01, %46
%48 = call double @exp(double %47)
%49 = load double*, double** %6
%50 = getelementptr inbounds double, double* %49, i64 14
%51 = load double, double* %50
%52 = fadd double %51, 6.501000e+01
%53 = fmul double 8.200000e-02, %52
%54 = call double @exp(double %53)
%55 = fmul double 6.270000e-01, %54
%56 = call double @llvm.fmuladd.f64(double 8.320000e-01, double %48, double %55)
%57 = fdiv double 6.247000e-04, %56
%58 = fadd double %57, 4.000000e-05
br label %76
59: ; preds = %34
%60 = load double*, double** %6
%61 = getelementptr inbounds double, double* %60, i64 14
%62 = load double, double* %61
%63 = fadd double %62, 5.670620e+01
%64 = fmul double -3.356600e-01, %63
%65 = call double @exp(double %64)
%66 = load double*, double** %6
%67 = getelementptr inbounds double, double* %66, i64 14
%68 = load double, double* %67
%69 = fadd double %68, 6.501310e+01
%70 = fmul double 0x3FB5119CE075F6FD, %69
%71 = call double @exp(double %70)
%72 = fmul double 0x3FE413A92A305532, %71
%73 = call double @llvm.fmuladd.f64(double 0x3FEAA184B50606AA, double %65, double %72)
%74 = fdiv double 6.247000e-04, %73
%75 = fadd double %74, 4.569000e-05
br label %76
76: ; preds = %59, %42
%77 = phi double [ %58, %42 ], [ %75, %59 ]
%78 = load double*, double** %8
%79 = getelementptr inbounds double, double* %78, i64 127
store double %77, double* %79
%80 = load double*, double** %8
%81 = getelementptr inbounds double, double* %80, i64 126
%82 = load double, double* %81
%83 = load double*, double** %6
%84 = getelementptr inbounds double, double* %83, i64 0
%85 = load double, double* %84
%86 = fsub double %82, %85
%87 = load double*, double** %8
%88 = getelementptr inbounds double, double* %87, i64 127
%89 = load double, double* %88
%90 = fdiv double %86, %89
%91 = load double*, double** %7
%92 = getelementptr inbounds double, double* %91, i64 0
store double %90, double* %92
%93 = load double*, double** %6
%94 = getelementptr inbounds double, double* %93, i64 14
%95 = load double, double* %94
%96 = fadd double %95, 6.610000e+01
%97 = fdiv double %96, 6.400000e+00
%98 = call double @exp(double %97)
%99 = fadd double 1.000000e+00, %98
%100 = fdiv double 1.000000e+00, %99
%101 = load double*, double** %8
%102 = getelementptr inbounds double, double* %101, i64 130
store double %100, double* %102
%103 = load double*, double** %6
%104 = getelementptr inbounds double, double* %103, i64 14
%105 = load double, double* %104
%106 = fadd double %105, 1.711000e+01
%107 = fmul double -2.815000e-01, %106
%108 = call double @exp(double %107)
%109 = fmul double 3.717000e-06, %108
%110 = load double*, double** %6
%111 = getelementptr inbounds double, double* %110, i64 14
%112 = load double, double* %111
%113 = fadd double %112, 3.776000e+01
%114 = fmul double -3.426000e-01, %113
%115 = call double @exp(double %114)
%116 = call double @llvm.fmuladd.f64(double 3.732000e-03, double %115, double 1.000000e+00)
%117 = fdiv double %109, %116
%118 = fadd double %117, 5.977000e-04
%119 = load double*, double** %8
%120 = getelementptr inbounds double, double* %119, i64 132
store double %118, double* %120
%121 = load double*, double** %8
%122 = getelementptr inbounds double, double* %121, i64 130
%123 = load double, double* %122
%124 = load double*, double** %6
%125 = getelementptr inbounds double, double* %124, i64 1
%126 = load double, double* %125
%127 = fsub double %123, %126
%128 = load double*, double** %8
%129 = getelementptr inbounds double, double* %128, i64 132
%130 = load double, double* %129
%131 = fdiv double %127, %130
%132 = load double*, double** %7
%133 = getelementptr inbounds double, double* %132, i64 1
store double %131, double* %133
%134 = load double*, double** %8
%135 = getelementptr inbounds double, double* %134, i64 130
%136 = load double, double* %135
%137 = load double*, double** %8
%138 = getelementptr inbounds double, double* %137, i64 131
store double %136, double* %138
%139 = load double*, double** %6
%140 = getelementptr inbounds double, double* %139, i64 14
%141 = load double, double* %140
%142 = fadd double %141, 1.880000e+01
%143 = fmul double -6.219000e-01, %142
%144 = call double @exp(double %143)
%145 = fmul double 3.186000e-08, %144
%146 = load double*, double** %6
%147 = getelementptr inbounds double, double* %146, i64 14
%148 = load double, double* %147
%149 = fadd double %148, 3.407000e+01
%150 = fmul double -6.683000e-01, %149
%151 = call double @exp(double %150)
%152 = call double @llvm.fmuladd.f64(double 7.189000e-05, double %151, double 1.000000e+00)
%153 = fdiv double %145, %152
%154 = fadd double %153, 3.556000e-03
%155 = load double*, double** %8
%156 = getelementptr inbounds double, double* %155, i64 133
store double %154, double* %156
%157 = load double*, double** %8
%158 = getelementptr inbounds double, double* %157, i64 131
%159 = load double, double* %158
%160 = load double*, double** %6
%161 = getelementptr inbounds double, double* %160, i64 2
%162 = load double, double* %161
%163 = fsub double %159, %162
%164 = load double*, double** %8
%165 = getelementptr inbounds double, double* %164, i64 133
%166 = load double, double* %165
%167 = fdiv double %163, %166
%168 = load double*, double** %7
%169 = getelementptr inbounds double, double* %168, i64 2
store double %167, double* %169
%170 = load double*, double** %8
%171 = getelementptr inbounds double, double* %170, i64 56
%172 = load double, double* %171
%173 = fcmp oeq double %172, 0.000000e+00
br i1 %173, label %174, label %184
174: ; preds = %76
%175 = load double*, double** %6
%176 = getelementptr inbounds double, double* %175, i64 14
%177 = load double, double* %176
%178 = fadd double %177, 2.310000e+01
%179 = fneg double %178
%180 = fdiv double %179, 6.000000e+00
%181 = call double @exp(double %180)
%182 = fadd double 1.000000e+00, %181
%183 = fdiv double 1.000000e+00, %182
br label %215
184: ; preds = %76
%185 = load double*, double** %8
%186 = getelementptr inbounds double, double* %185, i64 56
%187 = load double, double* %186
%188 = fcmp oeq double %187, 1.000000e+00
br i1 %188, label %189, label %203
189: ; preds = %184
%190 = load double*, double** %6
%191 = getelementptr inbounds double, double* %190, i64 14
%192 = load double, double* %191
%193 = fadd double %192, 2.230000e+01
%194 = load double*, double** %8
%195 = getelementptr inbounds double, double* %194, i64 110
%196 = load double, double* %195
%197 = call double @llvm.fmuladd.f64(double 8.000000e-01, double %196, double %193)
%198 = fneg double %197
%199 = fdiv double %198, 6.000000e+00
%200 = call double @exp(double %199)
%201 = fadd double 1.000000e+00, %200
%202 = fdiv double 1.000000e+00, %201
br label %213
203: ; preds = %184
%204 = load double*, double** %6
%205 = getelementptr inbounds double, double* %204, i64 14
%206 = load double, double* %205
%207 = fadd double %206, 2.220000e+01
%208 = fneg double %207
%209 = fdiv double %208, 6.000000e+00
%210 = call double @exp(double %209)
%211 = fadd double 1.000000e+00, %210
%212 = fdiv double 1.000000e+00, %211
br label %213
213: ; preds = %203, %189
%214 = phi double [ %202, %189 ], [ %212, %203 ]
br label %215
215: ; preds = %213, %174
%216 = phi double [ %183, %174 ], [ %214, %213 ]
%217 = load double*, double** %8
%218 = getelementptr inbounds double, double* %217, i64 139
store double %216, double* %218
%219 = load double*, double** %8
%220 = getelementptr inbounds double, double* %219, i64 56
%221 = load double, double* %220
%222 = fcmp oeq double %221, 0.000000e+00
br i1 %222, label %223, label %250
223: ; preds = %215
%224 = load double*, double** %6
%225 = getelementptr inbounds double, double* %224, i64 14
%226 = load double, double* %225
%227 = fadd double %226, 3.500000e+01
%228 = fmul double -2.838000e+01, %227
%229 = load double*, double** %6
%230 = getelementptr inbounds double, double* %229, i64 14
%231 = load double, double* %230
%232 = fadd double %231, 3.500000e+01
%233 = fneg double %232
%234 = fdiv double %233, 2.500000e+00
%235 = call double @exp(double %234)
%236 = fsub double %235, 1.000000e+00
%237 = fdiv double %228, %236
%238 = load double*, double** %6
%239 = getelementptr inbounds double, double* %238, i64 14
%240 = load double, double* %239
%241 = fmul double 8.490000e+01, %240
%242 = load double*, double** %6
%243 = getelementptr inbounds double, double* %242, i64 14
%244 = load double, double* %243
%245 = fmul double -2.080000e-01, %244
%246 = call double @exp(double %245)
%247 = fsub double %246, 1.000000e+00
%248 = fdiv double %241, %247
%249 = fsub double %237, %248
br label %311
250: ; preds = %215
%251 = load double*, double** %8
%252 = getelementptr inbounds double, double* %251, i64 56
%253 = load double, double* %252
%254 = fcmp oeq double %253, 1.000000e+00
br i1 %254, label %255, label %282
255: ; preds = %250
%256 = load double*, double** %6
%257 = getelementptr inbounds double, double* %256, i64 14
%258 = load double, double* %257
%259 = fadd double %258, 3.500000e+01
%260 = fmul double -2.839000e+01, %259
%261 = load double*, double** %6
%262 = getelementptr inbounds double, double* %261, i64 14
%263 = load double, double* %262
%264 = fadd double %263, 3.500000e+01
%265 = fneg double %264
%266 = fdiv double %265, 2.500000e+00
%267 = call double @exp(double %266)
%268 = fsub double %267, 1.000000e+00
%269 = fdiv double %260, %268
%270 = load double*, double** %6
%271 = getelementptr inbounds double, double* %270, i64 14
%272 = load double, double* %271
%273 = fmul double 8.490000e+01, %272
%274 = load double*, double** %6
%275 = getelementptr inbounds double, double* %274, i64 14
%276 = load double, double* %275
%277 = fmul double -2.080000e-01, %276
%278 = call double @exp(double %277)
%279 = fsub double %278, 1.000000e+00
%280 = fdiv double %273, %279
%281 = fsub double %269, %280
br label %309
282: ; preds = %250
%283 = load double*, double** %6
%284 = getelementptr inbounds double, double* %283, i64 14
%285 = load double, double* %284
%286 = fadd double %285, 3.500000e+01
%287 = fmul double -2.840000e+01, %286
%288 = load double*, double** %6
%289 = getelementptr inbounds double, double* %288, i64 14
%290 = load double, double* %289
%291 = fadd double %290, 3.500000e+01
%292 = fneg double %291
%293 = fdiv double %292, 2.500000e+00
%294 = call double @exp(double %293)
%295 = fsub double %294, 1.000000e+00
%296 = fdiv double %287, %295
%297 = load double*, double** %6
%298 = getelementptr inbounds double, double* %297, i64 14
%299 = load double, double* %298
%300 = fmul double 8.490000e+01, %299
%301 = load double*, double** %6
%302 = getelementptr inbounds double, double* %301, i64 14
%303 = load double, double* %302
%304 = fmul double -2.080000e-01, %303
%305 = call double @exp(double %304)
%306 = fsub double %305, 1.000000e+00
%307 = fdiv double %300, %306
%308 = fsub double %296, %307
br label %309
309: ; preds = %282, %255
%310 = phi double [ %281, %255 ], [ %308, %282 ]
br label %311
311: ; preds = %309, %223
%312 = phi double [ %249, %223 ], [ %310, %309 ]
%313 = load double*, double** %8
%314 = getelementptr inbounds double, double* %313, i64 136
store double %312, double* %314
%315 = load double*, double** %8
%316 = getelementptr inbounds double, double* %315, i64 56
%317 = load double, double* %316
%318 = fcmp oeq double %317, 1.000000e+00
br i1 %318, label %319, label %333
319: ; preds = %311
%320 = load double*, double** %6
%321 = getelementptr inbounds double, double* %320, i64 14
%322 = load double, double* %321
%323 = fsub double %322, 5.000000e+00
%324 = fmul double 1.143000e+01, %323
%325 = load double*, double** %6
%326 = getelementptr inbounds double, double* %325, i64 14
%327 = load double, double* %326
%328 = fsub double %327, 5.000000e+00
%329 = fmul double 4.000000e-01, %328
%330 = call double @exp(double %329)
%331 = fsub double %330, 1.000000e+00
%332 = fdiv double %324, %331
br label %347
333: ; preds = %311
%334 = load double*, double** %6
%335 = getelementptr inbounds double, double* %334, i64 14
%336 = load double, double* %335
%337 = fsub double %336, 5.000000e+00
%338 = fmul double 1.142000e+01, %337
%339 = load double*, double** %6
%340 = getelementptr inbounds double, double* %339, i64 14
%341 = load double, double* %340
%342 = fsub double %341, 5.000000e+00
%343 = fmul double 4.000000e-01, %342
%344 = call double @exp(double %343)
%345 = fsub double %344, 1.000000e+00
%346 = fdiv double %338, %345
br label %347
347: ; preds = %333, %319
%348 = phi double [ %332, %319 ], [ %346, %333 ]
%349 = load double*, double** %8
%350 = getelementptr inbounds double, double* %349, i64 137
store double %348, double* %350
%351 = load double*, double** %8
%352 = getelementptr inbounds double, double* %351, i64 136
%353 = load double, double* %352
%354 = load double*, double** %8
%355 = getelementptr inbounds double, double* %354, i64 137
%356 = load double, double* %355
%357 = fadd double %353, %356
%358 = fdiv double 2.000000e+00, %357
%359 = load double*, double** %8
%360 = getelementptr inbounds double, double* %359, i64 138
store double %358, double* %360
%361 = load double*, double** %8
%362 = getelementptr inbounds double, double* %361, i64 139
%363 = load double, double* %362
%364 = load double*, double** %6
%365 = getelementptr inbounds double, double* %364, i64 3
%366 = load double, double* %365
%367 = fsub double %363, %366
%368 = load double*, double** %8
%369 = getelementptr inbounds double, double* %368, i64 138
%370 = load double, double* %369
%371 = fdiv double %367, %370
%372 = load double*, double** %7
%373 = getelementptr inbounds double, double* %372, i64 3
store double %371, double* %373
%374 = load double*, double** %6
%375 = getelementptr inbounds double, double* %374, i64 14
%376 = load double, double* %375
%377 = fadd double %376, 4.500000e+01
%378 = fdiv double %377, 5.000000e+00
%379 = call double @exp(double %378)
%380 = fadd double 1.000000e+00, %379
%381 = fdiv double 1.000000e+00, %380
%382 = load double*, double** %8
%383 = getelementptr inbounds double, double* %382, i64 143
store double %381, double* %383
%384 = load double*, double** %8
%385 = getelementptr inbounds double, double* %384, i64 56
%386 = load double, double* %385
%387 = fcmp oeq double %386, 1.000000e+00
br i1 %387, label %388, label %402
388: ; preds = %347
%389 = load double*, double** %6
%390 = getelementptr inbounds double, double* %389, i64 14
%391 = load double, double* %390
%392 = fadd double %391, 2.800000e+01
%393 = fmul double 3.750000e+00, %392
%394 = load double*, double** %6
%395 = getelementptr inbounds double, double* %394, i64 14
%396 = load double, double* %395
%397 = fadd double %396, 2.800000e+01
%398 = fdiv double %397, 4.000000e+00
%399 = call double @exp(double %398)
%400 = fsub double %399, 1.000000e+00
%401 = fdiv double %393, %400
br label %416
402: ; preds = %347
%403 = load double*, double** %6
%404 = getelementptr inbounds double, double* %403, i64 14
%405 = load double, double* %404
%406 = fadd double %405, 2.800000e+01
%407 = fmul double 3.120000e+00, %406
%408 = load double*, double** %6
%409 = getelementptr inbounds double, double* %408, i64 14
%410 = load double, double* %409
%411 = fadd double %410, 2.800000e+01
%412 = fdiv double %411, 4.000000e+00
%413 = call double @exp(double %412)
%414 = fsub double %413, 1.000000e+00
%415 = fdiv double %407, %414
br label %416
416: ; preds = %402, %388
%417 = phi double [ %401, %388 ], [ %415, %402 ]
%418 = load double*, double** %8
%419 = getelementptr inbounds double, double* %418, i64 140
store double %417, double* %419
%420 = load double*, double** %8
%421 = getelementptr inbounds double, double* %420, i64 56
%422 = load double, double* %421
%423 = fcmp oeq double %422, 1.000000e+00
br i1 %423, label %424, label %434
424: ; preds = %416
%425 = load double*, double** %6
%426 = getelementptr inbounds double, double* %425, i64 14
%427 = load double, double* %426
%428 = fadd double %427, 2.800000e+01
%429 = fneg double %428
%430 = fdiv double %429, 4.000000e+00
%431 = call double @exp(double %430)
%432 = fadd double 1.000000e+00, %431
%433 = fdiv double 3.000000e+01, %432
br label %444
434: ; preds = %416
%435 = load double*, double** %6
%436 = getelementptr inbounds double, double* %435, i64 14
%437 = load double, double* %436
%438 = fadd double %437, 2.800000e+01
%439 = fneg double %438
%440 = fdiv double %439, 4.000000e+00
%441 = call double @exp(double %440)
%442 = fadd double 1.000000e+00, %441
%443 = fdiv double 2.500000e+01, %442
br label %444
444: ; preds = %434, %424
%445 = phi double [ %433, %424 ], [ %443, %434 ]
%446 = load double*, double** %8
%447 = getelementptr inbounds double, double* %446, i64 141
store double %445, double* %447
%448 = load double*, double** %8
%449 = getelementptr inbounds double, double* %448, i64 56
%450 = load double, double* %449
%451 = fcmp oeq double %450, 1.000000e+00
br i1 %451, label %452, label %465
452: ; preds = %444
%453 = load double*, double** %8
%454 = getelementptr inbounds double, double* %453, i64 110
%455 = load double, double* %454
%456 = call double @llvm.fmuladd.f64(double -2.000000e-01, double %455, double 1.200000e+00)
%457 = load double*, double** %8
%458 = getelementptr inbounds double, double* %457, i64 140
%459 = load double, double* %458
%460 = load double*, double** %8
%461 = getelementptr inbounds double, double* %460, i64 141
%462 = load double, double* %461
%463 = fadd double %459, %462
%464 = fdiv double %456, %463
br label %474
465: ; preds = %444
%466 = load double*, double** %8
%467 = getelementptr inbounds double, double* %466, i64 140
%468 = load double, double* %467
%469 = load double*, double** %8
%470 = getelementptr inbounds double, double* %469, i64 141
%471 = load double, double* %470
%472 = fadd double %468, %471
%473 = fdiv double 1.000000e+00, %472
br label %474
474: ; preds = %465, %452
%475 = phi double [ %464, %452 ], [ %473, %465 ]
%476 = load double*, double** %8
%477 = getelementptr inbounds double, double* %476, i64 142
store double %475, double* %477
%478 = load double*, double** %8
%479 = getelementptr inbounds double, double* %478, i64 143
%480 = load double, double* %479
%481 = load double*, double** %6
%482 = getelementptr inbounds double, double* %481, i64 4
%483 = load double, double* %482
%484 = fsub double %480, %483
%485 = load double*, double** %8
%486 = getelementptr inbounds double, double* %485, i64 142
%487 = load double, double* %486
%488 = fdiv double %484, %487
%489 = load double*, double** %7
%490 = getelementptr inbounds double, double* %489, i64 4
store double %488, double* %490
%491 = load double*, double** %6
%492 = getelementptr inbounds double, double* %491, i64 14
%493 = load double, double* %492
%494 = fadd double %493, 3.700000e+01
%495 = fneg double %494
%496 = fdiv double %495, 6.800000e+00
%497 = call double @exp(double %496)
%498 = fadd double 1.000000e+00, %497
%499 = fdiv double 1.000000e+00, %498
%500 = load double*, double** %8
%501 = getelementptr inbounds double, double* %500, i64 149
store double %499, double* %501
%502 = load double*, double** %6
%503 = getelementptr inbounds double, double* %502, i64 14
%504 = load double, double* %503
%505 = fadd double %504, 2.630000e+01
%506 = fdiv double %505, 3.000000e+01
%507 = call double @exp(double %506)
%508 = fmul double 1.068000e+03, %507
%509 = load double*, double** %8
%510 = getelementptr inbounds double, double* %509, i64 146
store double %508, double* %510
%511 = load double*, double** %6
%512 = getelementptr inbounds double, double* %511, i64 14
%513 = load double, double* %512
%514 = fadd double %513, 2.630000e+01
%515 = fneg double %514
%516 = fdiv double %515, 3.000000e+01
%517 = call double @exp(double %516)
%518 = fmul double 1.068000e+03, %517
%519 = load double*, double** %8
%520 = getelementptr inbounds double, double* %519, i64 147
store double %518, double* %520
%521 = load double*, double** %8
%522 = getelementptr inbounds double, double* %521, i64 146
%523 = load double, double* %522
%524 = load double*, double** %8
%525 = getelementptr inbounds double, double* %524, i64 147
%526 = load double, double* %525
%527 = fadd double %523, %526
%528 = fdiv double 1.000000e+00, %527
%529 = load double*, double** %8
%530 = getelementptr inbounds double, double* %529, i64 148
store double %528, double* %530
%531 = load double*, double** %8
%532 = getelementptr inbounds double, double* %531, i64 149
%533 = load double, double* %532
%534 = load double*, double** %6
%535 = getelementptr inbounds double, double* %534, i64 5
%536 = load double, double* %535
%537 = fsub double %533, %536
%538 = load double*, double** %8
%539 = getelementptr inbounds double, double* %538, i64 148
%540 = load double, double* %539
%541 = fdiv double %537, %540
%542 = load double*, double** %7
%543 = getelementptr inbounds double, double* %542, i64 5
store double %541, double* %543
%544 = load double*, double** %6
%545 = getelementptr inbounds double, double* %544, i64 14
%546 = load double, double* %545
%547 = fadd double %546, 7.100000e+01
%548 = fdiv double %547, 9.000000e+00
%549 = call double @exp(double %548)
%550 = fadd double 1.000000e+00, %549
%551 = fdiv double 1.000000e+00, %550
%552 = load double*, double** %8
%553 = getelementptr inbounds double, double* %552, i64 153
store double %551, double* %553
%554 = load double*, double** %8
%555 = getelementptr inbounds double, double* %554, i64 56
%556 = load double, double* %555
%557 = fcmp oeq double %556, 1.000000e+00
br i1 %557, label %558, label %571
558: ; preds = %474
%559 = load double*, double** %6
%560 = getelementptr inbounds double, double* %559, i64 14
%561 = load double, double* %560
%562 = fadd double %561, 7.100000e+01
%563 = load double*, double** %8
%564 = getelementptr inbounds double, double* %563, i64 110
%565 = load double, double* %564
%566 = call double @llvm.fmuladd.f64(double 0x3FE6666666666666, double %565, double %562)
%567 = fneg double %566
%568 = fdiv double %567, 0x4054D33333333333
%569 = call double @exp(double %568)
%570 = fmul double 1.530000e+01, %569
br label %580
571: ; preds = %474
%572 = load double*, double** %6
%573 = getelementptr inbounds double, double* %572, i64 14
%574 = load double, double* %573
%575 = fadd double %574, 7.170000e+01
%576 = fneg double %575
%577 = fdiv double %576, 0x4054D33333333333
%578 = call double @exp(double %577)
%579 = fmul double 1.530000e+01, %578
br label %580
580: ; preds = %571, %558
%581 = phi double [ %570, %558 ], [ %579, %571 ]
%582 = load double*, double** %8
%583 = getelementptr inbounds double, double* %582, i64 150
store double %581, double* %583
%584 = load double*, double** %8
%585 = getelementptr inbounds double, double* %584, i64 56
%586 = load double, double* %585
%587 = fcmp oeq double %586, 1.000000e+00
br i1 %587, label %588, label %596
588: ; preds = %580
%589 = load double*, double** %6
%590 = getelementptr inbounds double, double* %589, i64 14
%591 = load double, double* %590
%592 = fadd double %591, 7.100000e+01
%593 = fdiv double %592, 1.538000e+01
%594 = call double @exp(double %593)
%595 = fmul double 1.500000e+01, %594
br label %604
596: ; preds = %580
%597 = load double*, double** %6
%598 = getelementptr inbounds double, double* %597, i64 14
%599 = load double, double* %598
%600 = fadd double %599, 7.170000e+01
%601 = fdiv double %600, 1.538000e+01
%602 = call double @exp(double %601)
%603 = fmul double 1.500000e+01, %602
br label %604
604: ; preds = %596, %588
%605 = phi double [ %595, %588 ], [ %603, %596 ]
%606 = load double*, double** %8
%607 = getelementptr inbounds double, double* %606, i64 151
store double %605, double* %607
%608 = load double*, double** %8
%609 = getelementptr inbounds double, double* %608, i64 150
%610 = load double, double* %609
%611 = load double*, double** %8
%612 = getelementptr inbounds double, double* %611, i64 151
%613 = load double, double* %612
%614 = fadd double %610, %613
%615 = fdiv double 1.000000e+00, %614
%616 = load double*, double** %8
%617 = getelementptr inbounds double, double* %616, i64 152
store double %615, double* %617
%618 = load double*, double** %8
%619 = getelementptr inbounds double, double* %618, i64 153
%620 = load double, double* %619
%621 = load double*, double** %6
%622 = getelementptr inbounds double, double* %621, i64 6
%623 = load double, double* %622
%624 = fsub double %620, %623
%625 = load double*, double** %8
%626 = getelementptr inbounds double, double* %625, i64 152
%627 = load double, double* %626
%628 = fdiv double %624, %627
%629 = load double*, double** %7
%630 = getelementptr inbounds double, double* %629, i64 6
store double %628, double* %630
%631 = load double*, double** %6
%632 = getelementptr inbounds double, double* %631, i64 14
%633 = load double, double* %632
%634 = fadd double %633, 0x404DAF5C28F5C28F
%635 = fdiv double %634, 1.310000e+01
%636 = call double @exp(double %635)
%637 = fadd double 1.000000e+00, %636
%638 = fdiv double 1.000000e+00, %637
%639 = load double*, double** %8
%640 = getelementptr inbounds double, double* %639, i64 158
store double %638, double* %640
%641 = load double*, double** %8
%642 = getelementptr inbounds double, double* %641, i64 56
%643 = load double, double* %642
%644 = fcmp oeq double %643, 0.000000e+00
br i1 %644, label %645, label %662
645: ; preds = %604
%646 = load double*, double** %6
%647 = getelementptr inbounds double, double* %646, i64 14
%648 = load double, double* %647
%649 = fadd double %648, 4.900000e+01
%650 = fmul double -8.000000e-02, %649
%651 = call double @exp(double %650)
%652 = fmul double 5.700000e-01, %651
%653 = fdiv double 6.517000e-02, %652
%654 = fadd double 1.010000e-02, %653
%655 = load double*, double** %6
%656 = getelementptr inbounds double, double* %655, i64 14
%657 = load double, double* %656
%658 = fadd double %657, 5.093000e+01
%659 = fmul double 1.000000e-01, %658
%660 = call double @exp(double %659)
%661 = call double @llvm.fmuladd.f64(double 2.400000e-05, double %660, double %654)
br label %717
662: ; preds = %604
%663 = load double*, double** %8
%664 = getelementptr inbounds double, double* %663, i64 56
%665 = load double, double* %664
%666 = fcmp oeq double %665, 1.000000e+00
br i1 %666, label %667, label %698
667: ; preds = %662
%668 = load double*, double** %6
%669 = getelementptr inbounds double, double* %668, i64 14
%670 = load double, double* %669
%671 = fadd double %670, 3.900000e+01
%672 = load double*, double** %8
%673 = getelementptr inbounds double, double* %672, i64 110
%674 = load double, double* %673
%675 = call double @llvm.fmuladd.f64(double 1.000000e+01, double %674, double %671)
%676 = fmul double -8.161000e-02, %675
%677 = call double @exp(double %676)
%678 = load double*, double** %8
%679 = getelementptr inbounds double, double* %678, i64 110
%680 = load double, double* %679
%681 = call double @llvm.fmuladd.f64(double -1.719000e-01, double %680, double 2.719000e-01)
%682 = fmul double %681, 1.000000e+00
%683 = load double*, double** %6
%684 = getelementptr inbounds double, double* %683, i64 14
%685 = load double, double* %684
%686 = fadd double %685, 4.093000e+01
%687 = load double*, double** %8
%688 = getelementptr inbounds double, double* %687, i64 110
%689 = load double, double* %688
%690 = call double @llvm.fmuladd.f64(double 1.000000e+01, double %689, double %686)
%691 = fmul double %682, %690
%692 = call double @exp(double %691)
%693 = fmul double 7.174000e-01, %692
%694 = call double @llvm.fmuladd.f64(double 5.686000e-01, double %677, double %693)
%695 = fdiv double 1.955000e+02, %694
%696 = fadd double 3.031000e+01, %695
%697 = fmul double 0x3F35D867C3ECE2A5, %696
br label %715
698: ; preds = %662
%699 = load double*, double** %6
%700 = getelementptr inbounds double, double* %699, i64 14
%701 = load double, double* %700
%702 = fadd double %701, 3.900000e+01
%703 = fmul double -8.161000e-02, %702
%704 = call double @exp(double %703)
%705 = load double*, double** %6
%706 = getelementptr inbounds double, double* %705, i64 14
%707 = load double, double* %706
%708 = fadd double %707, 4.093000e+01
%709 = fmul double 2.719000e-01, %708
%710 = call double @exp(double %709)
%711 = fmul double 7.174000e-01, %710
%712 = call double @llvm.fmuladd.f64(double 5.686000e-01, double %704, double %711)
%713 = fdiv double 6.517000e-02, %712
%714 = fadd double 1.010000e-02, %713
br label %715
715: ; preds = %698, %667
%716 = phi double [ %697, %667 ], [ %714, %698 ]
br label %717
717: ; preds = %715, %645
%718 = phi double [ %661, %645 ], [ %716, %715 ]
%719 = load double*, double** %8
%720 = getelementptr inbounds double, double* %719, i64 159
store double %718, double* %720
%721 = load double*, double** %8
%722 = getelementptr inbounds double, double* %721, i64 158
%723 = load double, double* %722
%724 = load double*, double** %6
%725 = getelementptr inbounds double, double* %724, i64 7
%726 = load double, double* %725
%727 = fsub double %723, %726
%728 = load double*, double** %8
%729 = getelementptr inbounds double, double* %728, i64 159
%730 = load double, double* %729
%731 = fdiv double %727, %730
%732 = load double*, double** %7
%733 = getelementptr inbounds double, double* %732, i64 7
store double %731, double* %733
%734 = load double*, double** %6
%735 = getelementptr inbounds double, double* %734, i64 14
%736 = load double, double* %735
%737 = fsub double %736, 1.093000e+01
%738 = fneg double %737
%739 = fdiv double %738, 1.970000e+01
%740 = call double @exp(double %739)
%741 = fadd double 1.000000e+00, %740
%742 = fdiv double 1.000000e+00, %741
%743 = load double*, double** %8
%744 = getelementptr inbounds double, double* %743, i64 160
store double %742, double* %744
%745 = load double*, double** %8
%746 = getelementptr inbounds double, double* %745, i64 56
%747 = load double, double* %746
%748 = fcmp oeq double %747, 0.000000e+00
br i1 %748, label %749, label %767
749: ; preds = %717
%750 = load double*, double** %6
%751 = getelementptr inbounds double, double* %750, i64 14
%752 = load double, double* %751
%753 = fadd double %752, 3.061000e+01
%754 = fmul double 0x3FB70A3D70A3D70A, %753
%755 = call double @exp(double %754)
%756 = load double*, double** %6
%757 = getelementptr inbounds double, double* %756, i64 14
%758 = load double, double* %757
%759 = fadd double %758, 2.384000e+01
%760 = fmul double -1.200000e-01, %759
%761 = call double @exp(double %760)
%762 = fmul double 3.690000e-01, %761
%763 = call double @llvm.fmuladd.f64(double 1.037000e+00, double %755, double %762)
%764 = fdiv double 1.559000e+01, %763
%765 = fadd double 2.980000e+00, %764
%766 = fmul double 1.000000e-03, %765
br label %810
767: ; preds = %717
%768 = load double*, double** %8
%769 = getelementptr inbounds double, double* %768, i64 56
%770 = load double, double* %769
%771 = fcmp oeq double %770, 1.000000e+00
br i1 %771, label %772, label %790
772: ; preds = %767
%773 = load double*, double** %6
%774 = getelementptr inbounds double, double* %773, i64 14
%775 = load double, double* %774
%776 = fadd double %775, 3.061000e+01
%777 = fmul double 9.012000e-02, %776
%778 = call double @exp(double %777)
%779 = load double*, double** %6
%780 = getelementptr inbounds double, double* %779, i64 14
%781 = load double, double* %780
%782 = fadd double %781, 2.384000e+01
%783 = fmul double -1.190000e-01, %782
%784 = call double @exp(double %783)
%785 = fmul double 3.690000e-01, %784
%786 = call double @llvm.fmuladd.f64(double 1.037000e+00, double %778, double %785)
%787 = fdiv double 7.838000e+00, %786
%788 = fadd double 1.191000e+00, %787
%789 = fmul double 2.500000e-03, %788
br label %808
790: ; preds = %767
%791 = load double*, double** %6
%792 = getelementptr inbounds double, double* %791, i64 14
%793 = load double, double* %792
%794 = fadd double %793, 3.061000e+01
%795 = fmul double 9.012000e-02, %794
%796 = call double @exp(double %795)
%797 = load double*, double** %6
%798 = getelementptr inbounds double, double* %797, i64 14
%799 = load double, double* %798
%800 = fadd double %799, 2.384000e+01
%801 = fmul double -1.190000e-01, %800
%802 = call double @exp(double %801)
%803 = fmul double 3.690000e-01, %802
%804 = call double @llvm.fmuladd.f64(double 1.037000e+00, double %796, double %803)
%805 = fdiv double 1.959000e+01, %804
%806 = fadd double 2.980000e+00, %805
%807 = fmul double 1.000000e-03, %806
br label %808
808: ; preds = %790, %772
%809 = phi double [ %789, %772 ], [ %807, %790 ]
br label %810
810: ; preds = %808, %749
%811 = phi double [ %766, %749 ], [ %809, %808 ]
%812 = load double*, double** %8
%813 = getelementptr inbounds double, double* %812, i64 161
store double %811, double* %813
%814 = load double*, double** %8
%815 = getelementptr inbounds double, double* %814, i64 160
%816 = load double, double* %815
%817 = load double*, double** %6
%818 = getelementptr inbounds double, double* %817, i64 8
%819 = load double, double* %818
%820 = fsub double %816, %819
%821 = load double*, double** %8
%822 = getelementptr inbounds double, double* %821, i64 161
%823 = load double, double* %822
%824 = fdiv double %820, %823
%825 = load double*, double** %7
%826 = getelementptr inbounds double, double* %825, i64 8
store double %824, double* %826
%827 = load double*, double** %8
%828 = getelementptr inbounds double, double* %827, i64 56
%829 = load double, double* %828
%830 = fcmp une double %829, 2.000000e+00
br i1 %830, label %831, label %841
831: ; preds = %810
%832 = load double*, double** %6
%833 = getelementptr inbounds double, double* %832, i64 14
%834 = load double, double* %833
%835 = fadd double %834, 1.420000e+01
%836 = fneg double %835
%837 = fdiv double %836, 1.060000e+01
%838 = call double @exp(double %837)
%839 = fadd double 1.000000e+00, %838
%840 = fdiv double 1.000000e+00, %839
br label %851
841: ; preds = %810
%842 = load double*, double** %6
%843 = getelementptr inbounds double, double* %842, i64 14
%844 = load double, double* %843
%845 = fadd double %844, 1.320000e+01
%846 = fneg double %845
%847 = fdiv double %846, 1.060000e+01
%848 = call double @exp(double %847)
%849 = fadd double 1.000000e+00, %848
%850 = fdiv double 1.000000e+00, %849
br label %851
851: ; preds = %841, %831
%852 = phi double [ %840, %831 ], [ %850, %841 ]
%853 = load double*, double** %8
%854 = getelementptr inbounds double, double* %853, i64 164
store double %852, double* %854
%855 = load double*, double** %8
%856 = getelementptr inbounds double, double* %855, i64 56
%857 = load double, double* %856
%858 = fcmp une double %857, 2.000000e+00
br i1 %858, label %859, label %876
859: ; preds = %851
%860 = load double*, double** %6
%861 = getelementptr inbounds double, double* %860, i64 14
%862 = load double, double* %861
%863 = fsub double %862, 9.000000e+00
%864 = fdiv double %863, 1.590000e+01
%865 = call double @exp(double %864)
%866 = load double*, double** %6
%867 = getelementptr inbounds double, double* %866, i64 14
%868 = load double, double* %867
%869 = fsub double %868, 9.000000e+00
%870 = fneg double %869
%871 = fdiv double %870, 2.250000e+01
%872 = call double @exp(double %871)
%873 = fmul double 0x3FEEB851EB851EB8, %872
%874 = call double @llvm.fmuladd.f64(double 3.720000e+01, double %865, double %873)
%875 = fdiv double 1.000000e+00, %874
br label %893
876: ; preds = %851
%877 = load double*, double** %6
%878 = getelementptr inbounds double, double* %877, i64 14
%879 = load double, double* %878
%880 = fsub double %879, 1.000000e+01
%881 = fdiv double %880, 1.590000e+01
%882 = call double @exp(double %881)
%883 = load double*, double** %6
%884 = getelementptr inbounds double, double* %883, i64 14
%885 = load double, double* %884
%886 = fsub double %885, 1.000000e+01
%887 = fneg double %886
%888 = fdiv double %887, 2.250000e+01
%889 = call double @exp(double %888)
%890 = fmul double 0x3FEEB851EB851EB8, %889
%891 = call double @llvm.fmuladd.f64(double 3.720000e+01, double %882, double %890)
%892 = fdiv double 1.000000e+00, %891
br label %893
893: ; preds = %876, %859
%894 = phi double [ %875, %859 ], [ %892, %876 ]
%895 = load double*, double** %8
%896 = getelementptr inbounds double, double* %895, i64 165
store double %894, double* %896
%897 = load double*, double** %8
%898 = getelementptr inbounds double, double* %897, i64 164
%899 = load double, double* %898
%900 = load double*, double** %6
%901 = getelementptr inbounds double, double* %900, i64 9
%902 = load double, double* %901
%903 = fsub double %899, %902
%904 = load double*, double** %8
%905 = getelementptr inbounds double, double* %904, i64 165
%906 = load double, double* %905
%907 = fdiv double %903, %906
%908 = load double*, double** %7
%909 = getelementptr inbounds double, double* %908, i64 9
store double %907, double* %909
%910 = load double*, double** %8
%911 = getelementptr inbounds double, double* %910, i64 164
%912 = load double, double* %911
%913 = load double*, double** %8
%914 = getelementptr inbounds double, double* %913, i64 166
store double %912, double* %914
%915 = load double*, double** %8
%916 = getelementptr inbounds double, double* %915, i64 56
%917 = load double, double* %916
%918 = fcmp une double %917, 2.000000e+00
br i1 %918, label %919, label %936
919: ; preds = %893
%920 = load double*, double** %6
%921 = getelementptr inbounds double, double* %920, i64 14
%922 = load double, double* %921
%923 = fsub double %922, 9.000000e+00
%924 = fdiv double %923, 1.700000e+01
%925 = call double @exp(double %924)
%926 = load double*, double** %6
%927 = getelementptr inbounds double, double* %926, i64 14
%928 = load double, double* %927
%929 = fsub double %928, 9.000000e+00
%930 = fneg double %929
%931 = fdiv double %930, 2.160000e+01
%932 = call double @exp(double %931)
%933 = fmul double 1.500000e-01, %932
%934 = call double @llvm.fmuladd.f64(double 4.200000e+00, double %925, double %933)
%935 = fdiv double 1.000000e+00, %934
br label %953
936: ; preds = %893
%937 = load double*, double** %6
%938 = getelementptr inbounds double, double* %937, i64 14
%939 = load double, double* %938
%940 = fsub double %939, 1.000000e+01
%941 = fdiv double %940, 1.700000e+01
%942 = call double @exp(double %941)
%943 = load double*, double** %6
%944 = getelementptr inbounds double, double* %943, i64 14
%945 = load double, double* %944
%946 = fsub double %945, 1.000000e+01
%947 = fneg double %946
%948 = fdiv double %947, 2.160000e+01
%949 = call double @exp(double %948)
%950 = fmul double 1.500000e-01, %949
%951 = call double @llvm.fmuladd.f64(double 4.200000e+00, double %942, double %950)
%952 = fdiv double 1.000000e+00, %951
br label %953
953: ; preds = %936, %919
%954 = phi double [ %935, %919 ], [ %952, %936 ]
%955 = load double*, double** %8
%956 = getelementptr inbounds double, double* %955, i64 167
store double %954, double* %956
%957 = load double*, double** %8
%958 = getelementptr inbounds double, double* %957, i64 166
%959 = load double, double* %958
%960 = load double*, double** %6
%961 = getelementptr inbounds double, double* %960, i64 10
%962 = load double, double* %961
%963 = fsub double %959, %962
%964 = load double*, double** %8
%965 = getelementptr inbounds double, double* %964, i64 167
%966 = load double, double* %965
%967 = fdiv double %963, %966
%968 = load double*, double** %7
%969 = getelementptr inbounds double, double* %968, i64 10
store double %967, double* %969
%970 = load double*, double** %6
%971 = getelementptr inbounds double, double* %970, i64 14
%972 = load double, double* %971
%973 = fadd double %972, 1.860000e+01
%974 = fdiv double %973, 1.010000e+01
%975 = call double @exp(double %974)
%976 = fadd double 1.000000e+00, %975
%977 = fdiv double 1.000000e+00, %976
%978 = load double*, double** %8
%979 = getelementptr inbounds double, double* %978, i64 169
store double %977, double* %979
%980 = load double*, double** %8
%981 = getelementptr inbounds double, double* %980, i64 169
%982 = load double, double* %981
%983 = load double*, double** %6
%984 = getelementptr inbounds double, double* %983, i64 11
%985 = load double, double* %984
%986 = fsub double %982, %985
%987 = load double*, double** %8
%988 = getelementptr inbounds double, double* %987, i64 168
%989 = load double, double* %988
%990 = fdiv double %986, %989
%991 = load double*, double** %7
%992 = getelementptr inbounds double, double* %991, i64 11
store double %990, double* %992
%993 = load double*, double** %6
%994 = getelementptr inbounds double, double* %993, i64 14
%995 = load double, double* %994
%996 = fsub double %995, 4.000000e+01
%997 = fneg double %996
%998 = fdiv double %997, 9.000000e+00
%999 = call double @exp(double %998)
%1000 = fadd double 1.000000e+00, %999
%1001 = fdiv double 1.400000e+01, %1000
%1002 = load double*, double** %8
%1003 = getelementptr inbounds double, double* %1002, i64 172
store double %1001, double* %1003
%1004 = load double*, double** %6
%1005 = getelementptr inbounds double, double* %1004, i64 14
%1006 = load double, double* %1005
%1007 = fneg double %1006
%1008 = fdiv double %1007, 4.500000e+01
%1009 = call double @exp(double %1008)
%1010 = fmul double 1.000000e+00, %1009
%1011 = load double*, double** %8
%1012 = getelementptr inbounds double, double* %1011, i64 173
store double %1010, double* %1012
%1013 = load double*, double** %8
%1014 = getelementptr inbounds double, double* %1013, i64 172
%1015 = load double, double* %1014
%1016 = load double*, double** %6
%1017 = getelementptr inbounds double, double* %1016, i64 12
%1018 = load double, double* %1017
%1019 = fsub double 1.000000e+00, %1018
%1020 = load double*, double** %8
%1021 = getelementptr inbounds double, double* %1020, i64 173
%1022 = load double, double* %1021
%1023 = load double*, double** %6
%1024 = getelementptr inbounds double, double* %1023, i64 12
%1025 = load double, double* %1024
%1026 = fmul double %1022, %1025
%1027 = fneg double %1026
%1028 = call double @llvm.fmuladd.f64(double %1015, double %1019, double %1027)
%1029 = load double*, double** %7
%1030 = getelementptr inbounds double, double* %1029, i64 12
store double %1028, double* %1030
%1031 = load double*, double** %8
%1032 = getelementptr inbounds double, double* %1031, i64 56
%1033 = load double, double* %1032
%1034 = fcmp oeq double %1033, 0.000000e+00
br i1 %1034, label %1035, label %1044
1035: ; preds = %953
%1036 = load double*, double** %6
%1037 = getelementptr inbounds double, double* %1036, i64 14
%1038 = load double, double* %1037
%1039 = fadd double %1038, 7.891000e+01
%1040 = fneg double %1039
%1041 = fdiv double %1040, 2.662000e+01
%1042 = call double @exp(double %1041)
%1043 = fmul double 1.000000e+00, %1042
br label %1053
1044: ; preds = %953
%1045 = load double*, double** %6
%1046 = getelementptr inbounds double, double* %1045, i64 14
%1047 = load double, double* %1046
%1048 = fadd double %1047, 7.891000e+01
%1049 = fneg double %1048
%1050 = fdiv double %1049, 2.663000e+01
%1051 = call double @exp(double %1050)
%1052 = fmul double 1.000000e+00, %1051
br label %1053
1053: ; preds = %1044, %1035
%1054 = phi double [ %1043, %1035 ], [ %1052, %1044 ]
%1055 = load double*, double** %8
%1056 = getelementptr inbounds double, double* %1055, i64 178
store double %1054, double* %1056
%1057 = load double*, double** %6
%1058 = getelementptr inbounds double, double* %1057, i64 14
%1059 = load double, double* %1058
%1060 = fadd double %1059, 0x4052C851EB851EB8
%1061 = fdiv double %1060, 2.125000e+01
%1062 = call double @exp(double %1061)
%1063 = fmul double 1.000000e+00, %1062
%1064 = load double*, double** %8
%1065 = getelementptr inbounds double, double* %1064, i64 179
store double %1063, double* %1065
%1066 = load double*, double** %8
%1067 = getelementptr inbounds double, double* %1066, i64 178
%1068 = load double, double* %1067
%1069 = load double*, double** %6
%1070 = getelementptr inbounds double, double* %1069, i64 13
%1071 = load double, double* %1070
%1072 = fsub double 1.000000e+00, %1071
%1073 = load double*, double** %8
%1074 = getelementptr inbounds double, double* %1073, i64 179
%1075 = load double, double* %1074
%1076 = load double*, double** %6
%1077 = getelementptr inbounds double, double* %1076, i64 13
%1078 = load double, double* %1077
%1079 = fmul double %1075, %1078
%1080 = fneg double %1079
%1081 = call double @llvm.fmuladd.f64(double %1068, double %1072, double %1080)
%1082 = load double*, double** %7
%1083 = getelementptr inbounds double, double* %1082, i64 13
store double %1081, double* %1083
%1084 = load double*, double** %8
%1085 = getelementptr inbounds double, double* %1084, i64 117
%1086 = load double, double* %1085
%1087 = load double*, double** %8
%1088 = getelementptr inbounds double, double* %1087, i64 48
%1089 = load double, double* %1088
%1090 = load double*, double** %8
%1091 = getelementptr inbounds double, double* %1090, i64 103
%1092 = load double, double* %1091
%1093 = load double*, double** %8
%1094 = getelementptr inbounds double, double* %1093, i64 48
%1095 = load double, double* %1094
%1096 = fadd double %1092, %1095
%1097 = fdiv double %1089, %1096
%1098 = call double @pow(double %1097, double 3.000000e+00)
%1099 = fmul double %1086, %1098
%1100 = load double*, double** %8
%1101 = getelementptr inbounds double, double* %1100, i64 47
%1102 = load double, double* %1101
%1103 = load double*, double** %8
%1104 = getelementptr inbounds double, double* %1103, i64 102
%1105 = load double, double* %1104
%1106 = load double*, double** %8
%1107 = getelementptr inbounds double, double* %1106, i64 47
%1108 = load double, double* %1107
%1109 = fadd double %1105, %1108
%1110 = fdiv double %1102, %1109
%1111 = call double @pow(double %1110, double 2.000000e+00)
%1112 = fmul double %1099, %1111
%1113 = fmul double %1112, 1.600000e+00
%1114 = load double*, double** %6
%1115 = getelementptr inbounds double, double* %1114, i64 14
%1116 = load double, double* %1115
%1117 = fadd double %1116, 6.000000e+01
%1118 = fneg double %1117
%1119 = fdiv double %1118, 4.000000e+01
%1120 = call double @exp(double %1119)
%1121 = fadd double 1.500000e+00, %1120
%1122 = fdiv double %1113, %1121
%1123 = load double*, double** %8
%1124 = getelementptr inbounds double, double* %1123, i64 118
store double %1122, double* %1124
%1125 = load double*, double** %8
%1126 = getelementptr inbounds double, double* %1125, i64 56
%1127 = load double, double* %1126
%1128 = fcmp oeq double %1127, 0.000000e+00
br i1 %1128, label %1129, label %1193
1129: ; preds = %1053
%1130 = load double*, double** %8
%1131 = getelementptr inbounds double, double* %1130, i64 115
%1132 = load double, double* %1131
%1133 = load double*, double** %8
%1134 = getelementptr inbounds double, double* %1133, i64 48
%1135 = load double, double* %1134
%1136 = call double @pow(double %1135, double 3.000000e+00)
%1137 = load double*, double** %8
%1138 = getelementptr inbounds double, double* %1137, i64 45
%1139 = load double, double* %1138
%1140 = fmul double %1136, %1139
%1141 = load double*, double** %6
%1142 = getelementptr inbounds double, double* %1141, i64 14
%1143 = load double, double* %1142
%1144 = fmul double 3.743000e-02, %1143
%1145 = load double*, double** %8
%1146 = getelementptr inbounds double, double* %1145, i64 89
%1147 = load double, double* %1146
%1148 = fmul double %1144, %1147
%1149 = call double @exp(double %1148)
%1150 = load double*, double** %8
%1151 = getelementptr inbounds double, double* %1150, i64 49
%1152 = load double, double* %1151
%1153 = call double @pow(double %1152, double 3.000000e+00)
%1154 = load double*, double** %8
%1155 = getelementptr inbounds double, double* %1154, i64 44
%1156 = load double, double* %1155
%1157 = fmul double %1153, %1156
%1158 = load double*, double** %6
%1159 = getelementptr inbounds double, double* %1158, i64 14
%1160 = load double, double* %1159
%1161 = fmul double 3.740000e-02, %1160
%1162 = load double*, double** %8
%1163 = getelementptr inbounds double, double* %1162, i64 89
%1164 = load double, double* %1163
%1165 = fsub double %1164, 1.000000e+00
%1166 = fmul double %1161, %1165
%1167 = call double @exp(double %1166)
%1168 = fmul double %1157, %1167
%1169 = fneg double %1168
%1170 = call double @llvm.fmuladd.f64(double %1140, double %1149, double %1169)
%1171 = fmul double %1132, %1170
%1172 = load double*, double** %8
%1173 = getelementptr inbounds double, double* %1172, i64 88
%1174 = load double, double* %1173
%1175 = load double*, double** %8
%1176 = getelementptr inbounds double, double* %1175, i64 44
%1177 = load double, double* %1176
%1178 = load double*, double** %8
%1179 = getelementptr inbounds double, double* %1178, i64 49
%1180 = load double, double* %1179
%1181 = call double @pow(double %1180, double 3.000000e+00)
%1182 = load double*, double** %8
%1183 = getelementptr inbounds double, double* %1182, i64 45
%1184 = load double, double* %1183
%1185 = load double*, double** %8
%1186 = getelementptr inbounds double, double* %1185, i64 48
%1187 = load double, double* %1186
%1188 = call double @pow(double %1187, double 3.000000e+00)
%1189 = fmul double %1184, %1188
%1190 = call double @llvm.fmuladd.f64(double %1177, double %1181, double %1189)
%1191 = call double @llvm.fmuladd.f64(double %1174, double %1190, double 1.000000e+00)
%1192 = fdiv double %1171, %1191
br label %1257
1193: ; preds = %1053
%1194 = load double*, double** %8
%1195 = getelementptr inbounds double, double* %1194, i64 115
%1196 = load double, double* %1195
%1197 = load double*, double** %8
%1198 = getelementptr inbounds double, double* %1197, i64 48
%1199 = load double, double* %1198
%1200 = call double @pow(double %1199, double 3.000000e+00)
%1201 = load double*, double** %8
%1202 = getelementptr inbounds double, double* %1201, i64 45
%1203 = load double, double* %1202
%1204 = fmul double %1200, %1203
%1205 = load double*, double** %6
%1206 = getelementptr inbounds double, double* %1205, i64 14
%1207 = load double, double* %1206
%1208 = fmul double 3.743000e-02, %1207
%1209 = load double*, double** %8
%1210 = getelementptr inbounds double, double* %1209, i64 89
%1211 = load double, double* %1210
%1212 = fmul double %1208, %1211
%1213 = call double @exp(double %1212)
%1214 = load double*, double** %8
%1215 = getelementptr inbounds double, double* %1214, i64 49
%1216 = load double, double* %1215
%1217 = call double @pow(double %1216, double 3.000000e+00)
%1218 = load double*, double** %8
%1219 = getelementptr inbounds double, double* %1218, i64 44
%1220 = load double, double* %1219
%1221 = fmul double %1217, %1220
%1222 = load double*, double** %6
%1223 = getelementptr inbounds double, double* %1222, i64 14
%1224 = load double, double* %1223
%1225 = fmul double 3.743000e-02, %1224
%1226 = load double*, double** %8
%1227 = getelementptr inbounds double, double* %1226, i64 89
%1228 = load double, double* %1227
%1229 = fsub double %1228, 1.000000e+00
%1230 = fmul double %1225, %1229
%1231 = call double @exp(double %1230)
%1232 = fmul double %1221, %1231
%1233 = fneg double %1232
%1234 = call double @llvm.fmuladd.f64(double %1204, double %1213, double %1233)
%1235 = fmul double %1196, %1234
%1236 = load double*, double** %8
%1237 = getelementptr inbounds double, double* %1236, i64 88
%1238 = load double, double* %1237
%1239 = load double*, double** %8
%1240 = getelementptr inbounds double, double* %1239, i64 44
%1241 = load double, double* %1240
%1242 = load double*, double** %8
%1243 = getelementptr inbounds double, double* %1242, i64 49
%1244 = load double, double* %1243
%1245 = call double @pow(double %1244, double 3.000000e+00)
%1246 = load double*, double** %8
%1247 = getelementptr inbounds double, double* %1246, i64 45
%1248 = load double, double* %1247
%1249 = load double*, double** %8
%1250 = getelementptr inbounds double, double* %1249, i64 48
%1251 = load double, double* %1250
%1252 = call double @pow(double %1251, double 3.000000e+00)
%1253 = fmul double %1248, %1252
%1254 = call double @llvm.fmuladd.f64(double %1241, double %1245, double %1253)
%1255 = call double @llvm.fmuladd.f64(double %1238, double %1254, double 1.000000e+00)
%1256 = fdiv double %1235, %1255
br label %1257
1257: ; preds = %1193, %1129
%1258 = phi double [ %1192, %1129 ], [ %1256, %1193 ]
%1259 = load double*, double** %8
%1260 = getelementptr inbounds double, double* %1259, i64 116
store double %1258, double* %1260
%1261 = load double*, double** %8
%1262 = getelementptr inbounds double, double* %1261, i64 56
%1263 = load double, double* %1262
%1264 = fcmp une double %1263, 2.000000e+00
br i1 %1264, label %1265, label %1281
1265: ; preds = %1257
%1266 = load double*, double** %8
%1267 = getelementptr inbounds double, double* %1266, i64 176
%1268 = load double, double* %1267
%1269 = load double*, double** %6
%1270 = getelementptr inbounds double, double* %1269, i64 13
%1271 = load double, double* %1270
%1272 = fmul double %1268, %1271
%1273 = load double*, double** %6
%1274 = getelementptr inbounds double, double* %1273, i64 14
%1275 = load double, double* %1274
%1276 = load double*, double** %8
%1277 = getelementptr inbounds double, double* %1276, i64 122
%1278 = load double, double* %1277
%1279 = fsub double %1275, %1278
%1280 = fmul double %1272, %1279
br label %1294
1281: ; preds = %1257
%1282 = load double*, double** %8
%1283 = getelementptr inbounds double, double* %1282, i64 176
%1284 = load double, double* %1283
%1285 = load double*, double** %6
%1286 = getelementptr inbounds double, double* %1285, i64 13
%1287 = load double, double* %1286
%1288 = fmul double %1284, %1287
%1289 = load double*, double** %6
%1290 = getelementptr inbounds double, double* %1289, i64 14
%1291 = load double, double* %1290
%1292 = fadd double %1291, 1.020000e+02
%1293 = fmul double %1288, %1292
br label %1294
1294: ; preds = %1281, %1265
%1295 = phi double [ %1280, %1265 ], [ %1293, %1281 ]
%1296 = load double*, double** %8
%1297 = getelementptr inbounds double, double* %1296, i64 177
store double %1295, double* %1297
%1298 = load double*, double** %8
%1299 = getelementptr inbounds double, double* %1298, i64 56
%1300 = load double, double* %1299
%1301 = fcmp une double %1300, 2.000000e+00
br i1 %1301, label %1302, label %1318
1302: ; preds = %1294
%1303 = load double*, double** %8
%1304 = getelementptr inbounds double, double* %1303, i64 174
%1305 = load double, double* %1304
%1306 = load double*, double** %6
%1307 = getelementptr inbounds double, double* %1306, i64 13
%1308 = load double, double* %1307
%1309 = fmul double %1305, %1308
%1310 = load double*, double** %6
%1311 = getelementptr inbounds double, double* %1310, i64 14
%1312 = load double, double* %1311
%1313 = load double*, double** %8
%1314 = getelementptr inbounds double, double* %1313, i64 121
%1315 = load double, double* %1314
%1316 = fsub double %1312, %1315
%1317 = fmul double %1309, %1316
br label %1331
1318: ; preds = %1294
%1319 = load double*, double** %8
%1320 = getelementptr inbounds double, double* %1319, i64 174
%1321 = load double, double* %1320
%1322 = load double*, double** %6
%1323 = getelementptr inbounds double, double* %1322, i64 13
%1324 = load double, double* %1323
%1325 = fmul double %1321, %1324
%1326 = load double*, double** %6
%1327 = getelementptr inbounds double, double* %1326, i64 14
%1328 = load double, double* %1327
%1329 = fsub double %1328, 7.760000e+01
%1330 = fmul double %1325, %1329
br label %1331
1331: ; preds = %1318, %1302
%1332 = phi double [ %1317, %1302 ], [ %1330, %1318 ]
%1333 = load double*, double** %8
%1334 = getelementptr inbounds double, double* %1333, i64 175
store double %1332, double* %1334
%1335 = load double*, double** %8
%1336 = getelementptr inbounds double, double* %1335, i64 170
%1337 = load double, double* %1336
%1338 = load double*, double** %6
%1339 = getelementptr inbounds double, double* %1338, i64 12
%1340 = load double, double* %1339
%1341 = call double @pow(double %1340, double 2.000000e+00)
%1342 = fmul double %1337, %1341
%1343 = load double*, double** %6
%1344 = getelementptr inbounds double, double* %1343, i64 14
%1345 = load double, double* %1344
%1346 = load double*, double** %8
%1347 = getelementptr inbounds double, double* %1346, i64 124
%1348 = load double, double* %1347
%1349 = fsub double %1345, %1348
%1350 = fmul double %1342, %1349
%1351 = load double*, double** %8
%1352 = getelementptr inbounds double, double* %1351, i64 171
store double %1350, double* %1352
%1353 = load double*, double** %8
%1354 = getelementptr inbounds double, double* %1353, i64 155
%1355 = load double, double* %1354
%1356 = load double*, double** %6
%1357 = getelementptr inbounds double, double* %1356, i64 8
%1358 = load double, double* %1357
%1359 = fmul double %1355, %1358
%1360 = load double*, double** %6
%1361 = getelementptr inbounds double, double* %1360, i64 14
%1362 = load double, double* %1361
%1363 = load double*, double** %8
%1364 = getelementptr inbounds double, double* %1363, i64 122
%1365 = load double, double* %1364
%1366 = fsub double %1362, %1365
%1367 = fmul double %1359, %1366
%1368 = load double*, double** %8
%1369 = getelementptr inbounds double, double* %1368, i64 157
store double %1367, double* %1369
%1370 = load double*, double** %8
%1371 = getelementptr inbounds double, double* %1370, i64 154
%1372 = load double, double* %1371
%1373 = load double*, double** %6
%1374 = getelementptr inbounds double, double* %1373, i64 7
%1375 = load double, double* %1374
%1376 = fmul double %1372, %1375
%1377 = load double*, double** %6
%1378 = getelementptr inbounds double, double* %1377, i64 8
%1379 = load double, double* %1378
%1380 = fmul double %1376, %1379
%1381 = load double*, double** %6
%1382 = getelementptr inbounds double, double* %1381, i64 14
%1383 = load double, double* %1382
%1384 = load double*, double** %8
%1385 = getelementptr inbounds double, double* %1384, i64 122
%1386 = load double, double* %1385
%1387 = fsub double %1383, %1386
%1388 = fmul double %1380, %1387
%1389 = load double*, double** %8
%1390 = getelementptr inbounds double, double* %1389, i64 156
store double %1388, double* %1390
%1391 = load double*, double** %8
%1392 = getelementptr inbounds double, double* %1391, i64 144
%1393 = load double, double* %1392
%1394 = load double*, double** %6
%1395 = getelementptr inbounds double, double* %1394, i64 5
%1396 = load double, double* %1395
%1397 = fmul double %1393, %1396
%1398 = load double*, double** %6
%1399 = getelementptr inbounds double, double* %1398, i64 6
%1400 = load double, double* %1399
%1401 = fmul double %1397, %1400
%1402 = load double*, double** %6
%1403 = getelementptr inbounds double, double* %1402, i64 14
%1404 = load double, double* %1403
%1405 = load double*, double** %8
%1406 = getelementptr inbounds double, double* %1405, i64 7
%1407 = load double, double* %1406
%1408 = fsub double %1404, %1407
%1409 = fmul double %1401, %1408
%1410 = load double*, double** %8
%1411 = getelementptr inbounds double, double* %1410, i64 145
store double %1409, double* %1411
%1412 = load double*, double** %8
%1413 = getelementptr inbounds double, double* %1412, i64 134
%1414 = load double, double* %1413
%1415 = load double*, double** %6
%1416 = getelementptr inbounds double, double* %1415, i64 4
%1417 = load double, double* %1416
%1418 = load double*, double** %6
%1419 = getelementptr inbounds double, double* %1418, i64 3
%1420 = load double, double* %1419
%1421 = load double*, double** %6
%1422 = getelementptr inbounds double, double* %1421, i64 14
%1423 = load double, double* %1422
%1424 = fadd double %1423, 1.410000e+01
%1425 = fneg double %1424
%1426 = fdiv double %1425, 6.000000e+00
%1427 = call double @exp(double %1426)
%1428 = fadd double 1.000000e+00, %1427
%1429 = fdiv double 6.000000e-03, %1428
%1430 = call double @llvm.fmuladd.f64(double %1417, double %1420, double %1429)
%1431 = fmul double %1414, %1430
%1432 = load double*, double** %6
%1433 = getelementptr inbounds double, double* %1432, i64 14
%1434 = load double, double* %1433
%1435 = load double*, double** %8
%1436 = getelementptr inbounds double, double* %1435, i64 0
%1437 = load double, double* %1436
%1438 = fsub double %1434, %1437
%1439 = fmul double %1431, %1438
%1440 = load double*, double** %8
%1441 = getelementptr inbounds double, double* %1440, i64 135
store double %1439, double* %1441
%1442 = load double*, double** %8
%1443 = getelementptr inbounds double, double* %1442, i64 56
%1444 = load double, double* %1443
%1445 = fcmp oeq double %1444, 0.000000e+00
br i1 %1445, label %1446, label %1463
1446: ; preds = %1331
%1447 = load double*, double** %6
%1448 = getelementptr inbounds double, double* %1447, i64 14
%1449 = load double, double* %1448
%1450 = fadd double %1449, 3.440000e+01
%1451 = fmul double -6.300000e-02, %1450
%1452 = call double @exp(double %1451)
%1453 = fmul double 9.520000e-02, %1452
%1454 = load double*, double** %6
%1455 = getelementptr inbounds double, double* %1454, i64 14
%1456 = load double, double* %1455
%1457 = fadd double %1456, 6.370000e+01
%1458 = fmul double -2.250000e-01, %1457
%1459 = call double @exp(double %1458)
%1460 = call double @llvm.fmuladd.f64(double 1.660000e+00, double %1459, double 1.000000e+00)
%1461 = fdiv double %1453, %1460
%1462 = fadd double %1461, 8.690000e-02
br label %1480
1463: ; preds = %1331
%1464 = load double*, double** %6
%1465 = getelementptr inbounds double, double* %1464, i64 14
%1466 = load double, double* %1465
%1467 = fadd double %1466, 3.440000e+01
%1468 = fmul double -6.306000e-02, %1467
%1469 = call double @exp(double %1468)
%1470 = fmul double 9.518000e-02, %1469
%1471 = load double*, double** %6
%1472 = getelementptr inbounds double, double* %1471, i64 14
%1473 = load double, double* %1472
%1474 = fadd double %1473, 6.370000e+01
%1475 = fmul double -2.251000e-01, %1474
%1476 = call double @exp(double %1475)
%1477 = call double @llvm.fmuladd.f64(double 1.662000e+00, double %1476, double 1.000000e+00)
%1478 = fdiv double %1470, %1477
%1479 = fadd double %1478, 0x3FB6410B630A9153
br label %1480
1480: ; preds = %1463, %1446
%1481 = phi double [ %1462, %1446 ], [ %1479, %1463 ]
%1482 = load double*, double** %8
%1483 = getelementptr inbounds double, double* %1482, i64 128
store double %1481, double* %1483
%1484 = load double*, double** %8
%1485 = getelementptr inbounds double, double* %1484, i64 128
%1486 = load double, double* %1485
%1487 = fsub double 1.000000e+00, %1486
%1488 = load double*, double** %6
%1489 = getelementptr inbounds double, double* %1488, i64 1
%1490 = load double, double* %1489
%1491 = load double*, double** %8
%1492 = getelementptr inbounds double, double* %1491, i64 128
%1493 = load double, double* %1492
%1494 = load double*, double** %6
%1495 = getelementptr inbounds double, double* %1494, i64 2
%1496 = load double, double* %1495
%1497 = fmul double %1493, %1496
%1498 = call double @llvm.fmuladd.f64(double %1487, double %1490, double %1497)
%1499 = load double*, double** %8
%1500 = getelementptr inbounds double, double* %1499, i64 129
store double %1498, double* %1500
%1501 = load double*, double** %8
%1502 = getelementptr inbounds double, double* %1501, i64 125
%1503 = load double, double* %1502
%1504 = load double*, double** %6
%1505 = getelementptr inbounds double, double* %1504, i64 0
%1506 = load double, double* %1505
%1507 = call double @pow(double %1506, double 3.000000e+00)
%1508 = fmul double %1503, %1507
%1509 = load double*, double** %8
%1510 = getelementptr inbounds double, double* %1509, i64 129
%1511 = load double, double* %1510
%1512 = fmul double %1508, %1511
%1513 = load double*, double** %8
%1514 = getelementptr inbounds double, double* %1513, i64 49
%1515 = load double, double* %1514
%1516 = fmul double %1512, %1515
%1517 = load double*, double** %8
%1518 = getelementptr inbounds double, double* %1517, i64 52
%1519 = load double, double* %1518
%1520 = call double @pow(double %1519, double 2.000000e+00)
%1521 = fmul double %1516, %1520
%1522 = load double*, double** %8
%1523 = getelementptr inbounds double, double* %1522, i64 54
%1524 = load double, double* %1523
%1525 = load double*, double** %8
%1526 = getelementptr inbounds double, double* %1525, i64 55
%1527 = load double, double* %1526
%1528 = fmul double %1524, %1527
%1529 = fdiv double %1521, %1528
%1530 = load double*, double** %6
%1531 = getelementptr inbounds double, double* %1530, i64 14
%1532 = load double, double* %1531
%1533 = load double*, double** %8
%1534 = getelementptr inbounds double, double* %1533, i64 121
%1535 = load double, double* %1534
%1536 = fsub double %1532, %1535
%1537 = load double*, double** %8
%1538 = getelementptr inbounds double, double* %1537, i64 52
%1539 = load double, double* %1538
%1540 = fmul double %1536, %1539
%1541 = load double*, double** %8
%1542 = getelementptr inbounds double, double* %1541, i64 54
%1543 = load double, double* %1542
%1544 = load double*, double** %8
%1545 = getelementptr inbounds double, double* %1544, i64 55
%1546 = load double, double* %1545
%1547 = fmul double %1543, %1546
%1548 = fdiv double %1540, %1547
%1549 = call double @exp(double %1548)
%1550 = fsub double %1549, 1.000000e+00
%1551 = fmul double %1529, %1550
%1552 = load double*, double** %6
%1553 = getelementptr inbounds double, double* %1552, i64 14
%1554 = load double, double* %1553
%1555 = load double*, double** %8
%1556 = getelementptr inbounds double, double* %1555, i64 52
%1557 = load double, double* %1556
%1558 = fmul double %1554, %1557
%1559 = load double*, double** %8
%1560 = getelementptr inbounds double, double* %1559, i64 54
%1561 = load double, double* %1560
%1562 = load double*, double** %8
%1563 = getelementptr inbounds double, double* %1562, i64 55
%1564 = load double, double* %1563
%1565 = fmul double %1561, %1564
%1566 = fdiv double %1558, %1565
%1567 = call double @exp(double %1566)
%1568 = fsub double %1567, 1.000000e+00
%1569 = fdiv double %1551, %1568
%1570 = load double*, double** %6
%1571 = getelementptr inbounds double, double* %1570, i64 14
%1572 = load double, double* %1571
%1573 = fmul double %1569, %1572
%1574 = load double*, double** %8
%1575 = getelementptr inbounds double, double* %1574, i64 183
store double %1573, double* %1575
%1576 = load double*, double** %8
%1577 = getelementptr inbounds double, double* %1576, i64 113
%1578 = load double, double* %1577
%1579 = load double*, double** %6
%1580 = getelementptr inbounds double, double* %1579, i64 14
%1581 = load double, double* %1580
%1582 = load double*, double** %8
%1583 = getelementptr inbounds double, double* %1582, i64 122
%1584 = load double, double* %1583
%1585 = fsub double %1581, %1584
%1586 = fmul double %1578, %1585
%1587 = load double*, double** %8
%1588 = getelementptr inbounds double, double* %1587, i64 181
store double %1586, double* %1588
%1589 = load double*, double** %8
%1590 = getelementptr inbounds double, double* %1589, i64 114
%1591 = load double, double* %1590
%1592 = load double*, double** %6
%1593 = getelementptr inbounds double, double* %1592, i64 14
%1594 = load double, double* %1593
%1595 = load double*, double** %8
%1596 = getelementptr inbounds double, double* %1595, i64 123
%1597 = load double, double* %1596
%1598 = fsub double %1594, %1597
%1599 = fmul double %1591, %1598
%1600 = load double*, double** %8
%1601 = getelementptr inbounds double, double* %1600, i64 182
store double %1599, double* %1601
%1602 = load double*, double** %8
%1603 = getelementptr inbounds double, double* %1602, i64 112
%1604 = load double, double* %1603
%1605 = load double*, double** %6
%1606 = getelementptr inbounds double, double* %1605, i64 14
%1607 = load double, double* %1606
%1608 = load double*, double** %8
%1609 = getelementptr inbounds double, double* %1608, i64 121
%1610 = load double, double* %1609
%1611 = fsub double %1607, %1610
%1612 = fmul double %1604, %1611
%1613 = load double*, double** %8
%1614 = getelementptr inbounds double, double* %1613, i64 180
store double %1612, double* %1614
%1615 = load double*, double** %6
%1616 = getelementptr inbounds double, double* %1615, i64 9
%1617 = load double, double* %1616
%1618 = load double*, double** %6
%1619 = getelementptr inbounds double, double* %1618, i64 10
%1620 = load double, double* %1619
%1621 = fmul double 4.000000e-01, %1620
%1622 = call double @llvm.fmuladd.f64(double 6.000000e-01, double %1617, double %1621)
%1623 = load double*, double** %8
%1624 = getelementptr inbounds double, double* %1623, i64 163
store double %1622, double* %1624
%1625 = load double*, double** %8
%1626 = getelementptr inbounds double, double* %1625, i64 162
%1627 = load double, double* %1626
%1628 = load double*, double** %8
%1629 = getelementptr inbounds double, double* %1628, i64 163
%1630 = load double, double* %1629
%1631 = fmul double %1627, %1630
%1632 = load double*, double** %6
%1633 = getelementptr inbounds double, double* %1632, i64 11
%1634 = load double, double* %1633
%1635 = fmul double %1631, %1634
%1636 = load double*, double** %6
%1637 = getelementptr inbounds double, double* %1636, i64 14
%1638 = load double, double* %1637
%1639 = load double*, double** %8
%1640 = getelementptr inbounds double, double* %1639, i64 122
%1641 = load double, double* %1640
%1642 = fsub double %1638, %1641
%1643 = fmul double %1635, %1642
%1644 = load double*, double** %8
%1645 = getelementptr inbounds double, double* %1644, i64 184
store double %1643, double* %1645
%1646 = load double*, double** %8
%1647 = getelementptr inbounds double, double* %1646, i64 111
%1648 = load double, double* %1647
%1649 = fdiv double -1.000000e+00, %1648
%1650 = load double*, double** %8
%1651 = getelementptr inbounds double, double* %1650, i64 183
%1652 = load double, double* %1651
%1653 = load double*, double** %8
%1654 = getelementptr inbounds double, double* %1653, i64 135
%1655 = load double, double* %1654
%1656 = fadd double %1652, %1655
%1657 = load double*, double** %8
%1658 = getelementptr inbounds double, double* %1657, i64 145
%1659 = load double, double* %1658
%1660 = fadd double %1656, %1659
%1661 = load double*, double** %8
%1662 = getelementptr inbounds double, double* %1661, i64 156
%1663 = load double, double* %1662
%1664 = fadd double %1660, %1663
%1665 = load double*, double** %8
%1666 = getelementptr inbounds double, double* %1665, i64 157
%1667 = load double, double* %1666
%1668 = fadd double %1664, %1667
%1669 = load double*, double** %8
%1670 = getelementptr inbounds double, double* %1669, i64 184
%1671 = load double, double* %1670
%1672 = fadd double %1668, %1671
%1673 = load double*, double** %8
%1674 = getelementptr inbounds double, double* %1673, i64 171
%1675 = load double, double* %1674
%1676 = fadd double %1672, %1675
%1677 = load double*, double** %8
%1678 = getelementptr inbounds double, double* %1677, i64 175
%1679 = load double, double* %1678
%1680 = fadd double %1676, %1679
%1681 = load double*, double** %8
%1682 = getelementptr inbounds double, double* %1681, i64 177
%1683 = load double, double* %1682
%1684 = fadd double %1680, %1683
%1685 = load double*, double** %8
%1686 = getelementptr inbounds double, double* %1685, i64 180
%1687 = load double, double* %1686
%1688 = fadd double %1684, %1687
%1689 = load double*, double** %8
%1690 = getelementptr inbounds double, double* %1689, i64 182
%1691 = load double, double* %1690
%1692 = fadd double %1688, %1691
%1693 = load double*, double** %8
%1694 = getelementptr inbounds double, double* %1693, i64 181
%1695 = load double, double* %1694
%1696 = fadd double %1692, %1695
%1697 = load double*, double** %8
%1698 = getelementptr inbounds double, double* %1697, i64 116
%1699 = load double, double* %1698
%1700 = fadd double %1696, %1699
%1701 = load double*, double** %8
%1702 = getelementptr inbounds double, double* %1701, i64 118
%1703 = load double, double* %1702
%1704 = fadd double %1700, %1703
%1705 = load double*, double** %8
%1706 = getelementptr inbounds double, double* %1705, i64 120
%1707 = load double, double* %1706
%1708 = fadd double %1704, %1707
%1709 = fmul double %1649, %1708
%1710 = load double*, double** %7
%1711 = getelementptr inbounds double, double* %1710, i64 14
store double %1709, double* %1711
ret void
}

LLVM IR (-O2):
define void @computeRates(double %0, double* %1, double* nocapture writeonly %2, double* %3) {
%5 = getelementptr inbounds double, double* %3, i64 56
%6 = load double, double* %5
%7 = fcmp oeq double %6, 0.000000e+00
%8 = getelementptr inbounds double, double* %1, i64 14
%9 = load double, double* %8
%10 = fadd double %9, 3.032000e+01
%11 = select i1 %7, double %9, double %10
%12 = fdiv double %11, -5.460000e+00
%13 = tail call double @exp(double %12)
%14 = fadd double %13, 1.000000e+00
%15 = fdiv double 1.000000e+00, %14
%16 = tail call double @pow(double %15, double 0x3FD5555555555555)
%17 = getelementptr inbounds double, double* %3, i64 126
store double %16, double* %17
%18 = load double, double* %5
%19 = fcmp oeq double %18, 0.000000e+00
%20 = getelementptr inbounds double, double* %1, i64 14
%21 = load double, double* %20
br i1 %19, label %22, label %32
22: ; preds = %4
%23 = fadd double %21, 5.670000e+01
%24 = fmul double %23, -3.350000e-01
%25 = tail call double @exp(double %24)
%26 = load double, double* %20
%27 = fadd double %26, 6.501000e+01
%28 = fmul double %27, 8.200000e-02
%29 = tail call double @exp(double %28)
%30 = fmul double %29, 6.270000e-01
%31 = tail call double @llvm.fmuladd.f64(double %25, double 8.320000e-01, double %30)
br label %42
32: ; preds = %4
%33 = fadd double %21, 5.670620e+01
%34 = fmul double %33, -3.356600e-01
%35 = tail call double @exp(double %34)
%36 = load double, double* %20
%37 = fadd double %36, 6.501310e+01
%38 = fmul double %37, 0x3FB5119CE075F6FD
%39 = tail call double @exp(double %38)
%40 = fmul double %39, 0x3FE413A92A305532
%41 = tail call double @llvm.fmuladd.f64(double %35, double 0x3FEAA184B50606AA, double %40)
br label %42
42: ; preds = %32, %22
%43 = phi double [ %41, %32 ], [ %31, %22 ]
%44 = phi double [ 4.569000e-05, %32 ], [ 4.000000e-05, %22 ]
%45 = fdiv double 6.247000e-04, %43
%46 = fadd double %45, %44
%47 = getelementptr inbounds double, double* %3, i64 127
store double %46, double* %47
%48 = load double, double* %17
%49 = load double, double* %1
%50 = fsub double %48, %49
%51 = fdiv double %50, %46
store double %51, double* %2
%52 = getelementptr inbounds double, double* %1, i64 14
%53 = load double, double* %52
%54 = fadd double %53, 6.610000e+01
%55 = fdiv double %54, 6.400000e+00
%56 = tail call double @exp(double %55)
%57 = fadd double %56, 1.000000e+00
%58 = fdiv double 1.000000e+00, %57
%59 = getelementptr inbounds double, double* %3, i64 130
store double %58, double* %59
%60 = load double, double* %52
%61 = fadd double %60, 1.711000e+01
%62 = fmul double %61, -2.815000e-01
%63 = tail call double @exp(double %62)
%64 = fmul double %63, 3.717000e-06
%65 = load double, double* %52
%66 = fadd double %65, 3.776000e+01
%67 = fmul double %66, -3.426000e-01
%68 = tail call double @exp(double %67)
%69 = tail call double @llvm.fmuladd.f64(double %68, double 3.732000e-03, double 1.000000e+00)
%70 = fdiv double %64, %69
%71 = fadd double %70, 5.977000e-04
%72 = getelementptr inbounds double, double* %3, i64 132
store double %71, double* %72
%73 = load double, double* %59
%74 = getelementptr inbounds double, double* %1, i64 1
%75 = load double, double* %74
%76 = fsub double %73, %75
%77 = fdiv double %76, %71
%78 = getelementptr inbounds double, double* %2, i64 1
store double %77, double* %78
%79 = load double, double* %59
%80 = getelementptr inbounds double, double* %3, i64 131
store double %79, double* %80
%81 = load double, double* %52
%82 = fadd double %81, 1.880000e+01
%83 = fmul double %82, -6.219000e-01
%84 = tail call double @exp(double %83)
%85 = fmul double %84, 3.186000e-08
%86 = load double, double* %52
%87 = fadd double %86, 3.407000e+01
%88 = fmul double %87, -6.683000e-01
%89 = tail call double @exp(double %88)
%90 = tail call double @llvm.fmuladd.f64(double %89, double 7.189000e-05, double 1.000000e+00)
%91 = fdiv double %85, %90
%92 = fadd double %91, 3.556000e-03
%93 = getelementptr inbounds double, double* %3, i64 133
store double %92, double* %93
%94 = load double, double* %80
%95 = getelementptr inbounds double, double* %1, i64 2
%96 = load double, double* %95
%97 = fsub double %94, %96
%98 = fdiv double %97, %92
%99 = getelementptr inbounds double, double* %2, i64 2
store double %98, double* %99
%100 = load double, double* %5
%101 = fcmp oeq double %100, 0.000000e+00
br i1 %101, label %102, label %105
102: ; preds = %42
%103 = load double, double* %52
%104 = fadd double %103, 2.310000e+01
br label %115
105: ; preds = %42
%106 = fcmp oeq double %100, 1.000000e+00
%107 = load double, double* %52
br i1 %106, label %108, label %113
108: ; preds = %105
%109 = fadd double %107, 2.230000e+01
%110 = getelementptr inbounds double, double* %3, i64 110
%111 = load double, double* %110
%112 = tail call double @llvm.fmuladd.f64(double %111, double 8.000000e-01, double %109)
br label %115
113: ; preds = %105
%114 = fadd double %107, 2.220000e+01
br label %115
115: ; preds = %108, %113, %102
%116 = phi double [ %112, %108 ], [ %114, %113 ], [ %104, %102 ]
%117 = fdiv double %116, -6.000000e+00
%118 = tail call double @exp(double %117)
%119 = fadd double %118, 1.000000e+00
%120 = fdiv double 1.000000e+00, %119
%121 = getelementptr inbounds double, double* %3, i64 139
store double %120, double* %121
%122 = load double, double* %5
%123 = fcmp oeq double %122, 0.000000e+00
br i1 %123, label %124, label %128
124: ; preds = %115
%125 = load double, double* %52
%126 = fadd double %125, 3.500000e+01
%127 = fmul double %126, -2.838000e+01
br label %136
128: ; preds = %115
%129 = fcmp oeq double %122, 1.000000e+00
%130 = load double, double* %52
%131 = fadd double %130, 3.500000e+01
br i1 %129, label %132, label %134
132: ; preds = %128
%133 = fmul double %131, -2.839000e+01
br label %136
134: ; preds = %128
%135 = fmul double %131, -2.840000e+01
br label %136
136: ; preds = %132, %134, %124
%137 = phi double [ %131, %132 ], [ %131, %134 ], [ %126, %124 ]
%138 = phi double [ %133, %132 ], [ %135, %134 ], [ %127, %124 ]
%139 = fdiv double %137, -2.500000e+00
%140 = tail call double @exp(double %139)
%141 = fadd double %140, -1.000000e+00
%142 = fdiv double %138, %141
%143 = load double, double* %52
%144 = fmul double %143, 8.490000e+01
%145 = fmul double %143, -2.080000e-01
%146 = tail call double @exp(double %145)
%147 = fadd double %146, -1.000000e+00
%148 = fdiv double %144, %147
%149 = fsub double %142, %148
%150 = getelementptr inbounds double, double* %3, i64 136
store double %149, double* %150
%151 = load double, double* %5
%152 = fcmp oeq double %151, 1.000000e+00
%153 = load double, double* %52
%154 = fadd double %153, -5.000000e+00
%155 = select i1 %152, double 1.143000e+01, double 1.142000e+01
%156 = fmul double %154, %155
%157 = fmul double %154, 4.000000e-01
%158 = tail call double @exp(double %157)
%159 = fadd double %158, -1.000000e+00
%160 = fdiv double %156, %159
%161 = getelementptr inbounds double, double* %3, i64 137
store double %160, double* %161
%162 = load double, double* %150
%163 = fadd double %160, %162
%164 = fdiv double 2.000000e+00, %163
%165 = getelementptr inbounds double, double* %3, i64 138
store double %164, double* %165
%166 = load double, double* %121
%167 = getelementptr inbounds double, double* %1, i64 3
%168 = load double, double* %167
%169 = fsub double %166, %168
%170 = fdiv double %169, %164
%171 = getelementptr inbounds double, double* %2, i64 3
store double %170, double* %171
%172 = load double, double* %52
%173 = fadd double %172, 4.500000e+01
%174 = fdiv double %173, 5.000000e+00
%175 = tail call double @exp(double %174)
%176 = fadd double %175, 1.000000e+00
%177 = fdiv double 1.000000e+00, %176
%178 = getelementptr inbounds double, double* %3, i64 143
store double %177, double* %178
%179 = load double, double* %5
%180 = fcmp oeq double %179, 1.000000e+00
%181 = load double, double* %52
%182 = fadd double %181, 2.800000e+01
%183 = select i1 %180, double 3.750000e+00, double 3.120000e+00
%184 = fmul double %182, %183
%185 = fmul double %182, 2.500000e-01
%186 = tail call double @exp(double %185)
%187 = fadd double %186, -1.000000e+00
%188 = fdiv double %184, %187
%189 = getelementptr inbounds double, double* %3, i64 140
store double %188, double* %189
%190 = load double, double* %5
%191 = fcmp oeq double %190, 1.000000e+00
%192 = select i1 %191, double 3.000000e+01, double 2.500000e+01
%193 = load double, double* %52
%194 = fadd double %193, 2.800000e+01
%195 = fmul double %194, -2.500000e-01
%196 = tail call double @exp(double %195)
%197 = fadd double %196, 1.000000e+00
%198 = fdiv double %192, %197
%199 = getelementptr inbounds double, double* %3, i64 141
store double %198, double* %199
%200 = load double, double* %5
%201 = fcmp oeq double %200, 1.000000e+00
br i1 %201, label %202, label %206
202: ; preds = %136
%203 = getelementptr inbounds double, double* %3, i64 110
%204 = load double, double* %203
%205 = tail call double @llvm.fmuladd.f64(double %204, double -2.000000e-01, double 1.200000e+00)
br label %206
206: ; preds = %136, %202
%207 = phi double [ %205, %202 ], [ 1.000000e+00, %136 ]
%208 = load double, double* %189
%209 = fadd double %198, %208
%210 = fdiv double %207, %209
%211 = getelementptr inbounds double, double* %3, i64 142
store double %210, double* %211
%212 = load double, double* %178
%213 = getelementptr inbounds double, double* %1, i64 4
%214 = load double, double* %213
%215 = fsub double %212, %214
%216 = fdiv double %215, %210
%217 = getelementptr inbounds double, double* %2, i64 4
store double %216, double* %217
%218 = load double, double* %52
%219 = fadd double %218, 3.700000e+01
%220 = fdiv double %219, -6.800000e+00
%221 = tail call double @exp(double %220)
%222 = fadd double %221, 1.000000e+00
%223 = fdiv double 1.000000e+00, %222
%224 = getelementptr inbounds double, double* %3, i64 149
store double %223, double* %224
%225 = load double, double* %52
%226 = fadd double %225, 2.630000e+01
%227 = fdiv double %226, 3.000000e+01
%228 = tail call double @exp(double %227)
%229 = fmul double %228, 1.068000e+03
%230 = getelementptr inbounds double, double* %3, i64 146
store double %229, double* %230
%231 = load double, double* %52
%232 = fadd double %231, 2.630000e+01
%233 = fdiv double %232, -3.000000e+01
%234 = tail call double @exp(double %233)
%235 = fmul double %234, 1.068000e+03
%236 = getelementptr inbounds double, double* %3, i64 147
store double %235, double* %236
%237 = load double, double* %230
%238 = fadd double %235, %237
%239 = fdiv double 1.000000e+00, %238
%240 = getelementptr inbounds double, double* %3, i64 148
store double %239, double* %240
%241 = load double, double* %224
%242 = getelementptr inbounds double, double* %1, i64 5
%243 = load double, double* %242
%244 = fsub double %241, %243
%245 = fdiv double %244, %239
%246 = getelementptr inbounds double, double* %2, i64 5
store double %245, double* %246
%247 = load double, double* %52
%248 = fadd double %247, 7.100000e+01
%249 = fdiv double %248, 9.000000e+00
%250 = tail call double @exp(double %249)
%251 = fadd double %250, 1.000000e+00
%252 = fdiv double 1.000000e+00, %251
%253 = getelementptr inbounds double, double* %3, i64 153
store double %252, double* %253
%254 = load double, double* %5
%255 = fcmp oeq double %254, 1.000000e+00
%256 = load double, double* %52
br i1 %255, label %257, label %262
257: ; preds = %206
%258 = fadd double %256, 7.100000e+01
%259 = getelementptr inbounds double, double* %3, i64 110
%260 = load double, double* %259
%261 = tail call double @llvm.fmuladd.f64(double %260, double 0x3FE6666666666666, double %258)
br label %264
262: ; preds = %206
%263 = fadd double %256, 7.170000e+01
br label %264
264: ; preds = %262, %257
%265 = phi double [ %263, %262 ], [ %261, %257 ]
%266 = fdiv double %265, 0xC054D33333333333
%267 = tail call double @exp(double %266)
%268 = fmul double %267, 1.530000e+01
%269 = getelementptr inbounds double, double* %3, i64 150
store double %268, double* %269
%270 = load double, double* %5
%271 = fcmp oeq double %270, 1.000000e+00
%272 = select i1 %271, double 7.100000e+01, double 7.170000e+01
%273 = load double, double* %52
%274 = fadd double %273, %272
%275 = fdiv double %274, 1.538000e+01
%276 = tail call double @exp(double %275)
%277 = fmul double %276, 1.500000e+01
%278 = getelementptr inbounds double, double* %3, i64 151
store double %277, double* %278
%279 = load double, double* %269
%280 = fadd double %277, %279
%281 = fdiv double 1.000000e+00, %280
%282 = getelementptr inbounds double, double* %3, i64 152
store double %281, double* %282
%283 = load double, double* %253
%284 = getelementptr inbounds double, double* %1, i64 6
%285 = load double, double* %284
%286 = fsub double %283, %285
%287 = fdiv double %286, %281
%288 = getelementptr inbounds double, double* %2, i64 6
store double %287, double* %288
%289 = load double, double* %52
%290 = fadd double %289, 0x404DAF5C28F5C28F
%291 = fdiv double %290, 1.310000e+01
%292 = tail call double @exp(double %291)
%293 = fadd double %292, 1.000000e+00
%294 = fdiv double 1.000000e+00, %293
%295 = getelementptr inbounds double, double* %3, i64 158
store double %294, double* %295
%296 = load double, double* %5
%297 = fcmp oeq double %296, 0.000000e+00
br i1 %297, label %298, label %311
298: ; preds = %264
%299 = load double, double* %52
%300 = fadd double %299, 4.900000e+01
%301 = fmul double %300, -8.000000e-02
%302 = tail call double @exp(double %301)
%303 = fmul double %302, 5.700000e-01
%304 = fdiv double 6.517000e-02, %303
%305 = fadd double %304, 1.010000e-02
%306 = load double, double* %52
%307 = fadd double %306, 5.093000e+01
%308 = fmul double %307, 1.000000e-01
%309 = tail call double @exp(double %308)
%310 = tail call double @llvm.fmuladd.f64(double %309, double 2.400000e-05, double %305)
br label %348
311: ; preds = %264
%312 = fcmp oeq double %296, 1.000000e+00
%313 = load double, double* %52
%314 = fadd double %313, 3.900000e+01
br i1 %312, label %315, label %337
315: ; preds = %311
%316 = getelementptr inbounds double, double* %3, i64 110
%317 = load double, double* %316
%318 = tail call double @llvm.fmuladd.f64(double %317, double 1.000000e+01, double %314)
%319 = fmul double %318, -8.161000e-02
%320 = tail call double @exp(double %319)
%321 = load double, double* %316
%322 = load double, double* %52
%323 = fadd double %322, 4.093000e+01
%324 = insertelement <2 x double> poison, double %321, i64 0
%325 = shufflevector <2 x double> %324, <2 x double> poison, <2 x i32> zeroinitializer
%326 = insertelement <2 x double> <double 2.719000e-01, double poison>, double %323, i64 1
%327 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %325, <2 x double> <double -1.719000e-01, double 1.000000e+01>, <2 x double> %326)
%328 = shufflevector <2 x double> %327, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%329 = fmul <2 x double> %327, %328
%330 = extractelement <2 x double> %329, i64 0
%331 = tail call double @exp(double %330)
%332 = fmul double %331, 7.174000e-01
%333 = tail call double @llvm.fmuladd.f64(double %320, double 5.686000e-01, double %332)
%334 = fdiv double 1.955000e+02, %333
%335 = fadd double %334, 3.031000e+01
%336 = fmul double %335, 0x3F35D867C3ECE2A5
br label %348
337: ; preds = %311
%338 = fmul double %314, -8.161000e-02
%339 = tail call double @exp(double %338)
%340 = load double, double* %52
%341 = fadd double %340, 4.093000e+01
%342 = fmul double %341, 2.719000e-01
%343 = tail call double @exp(double %342)
%344 = fmul double %343, 7.174000e-01
%345 = tail call double @llvm.fmuladd.f64(double %339, double 5.686000e-01, double %344)
%346 = fdiv double 6.517000e-02, %345
%347 = fadd double %346, 1.010000e-02
br label %348
348: ; preds = %315, %337, %298
%349 = phi double [ %310, %298 ], [ %336, %315 ], [ %347, %337 ]
%350 = getelementptr inbounds double, double* %3, i64 159
store double %349, double* %350
%351 = load double, double* %295
%352 = getelementptr inbounds double, double* %1, i64 7
%353 = load double, double* %352
%354 = fsub double %351, %353
%355 = fdiv double %354, %349
%356 = getelementptr inbounds double, double* %2, i64 7
store double %355, double* %356
%357 = load double, double* %52
%358 = fadd double %357, -1.093000e+01
%359 = fdiv double %358, -1.970000e+01
%360 = tail call double @exp(double %359)
%361 = fadd double %360, 1.000000e+00
%362 = fdiv double 1.000000e+00, %361
%363 = getelementptr inbounds double, double* %3, i64 160
store double %362, double* %363
%364 = load double, double* %5
%365 = fcmp oeq double %364, 0.000000e+00
br i1 %365, label %366, label %380
366: ; preds = %348
%367 = load double, double* %52
%368 = fadd double %367, 3.061000e+01
%369 = fmul double %368, 0x3FB70A3D70A3D70A
%370 = tail call double @exp(double %369)
%371 = load double, double* %52
%372 = fadd double %371, 2.384000e+01
%373 = fmul double %372, -1.200000e-01
%374 = tail call double @exp(double %373)
%375 = fmul double %374, 3.690000e-01
%376 = tail call double @llvm.fmuladd.f64(double %370, double 1.037000e+00, double %375)
%377 = fdiv double 1.559000e+01, %376
%378 = fadd double %377, 2.980000e+00
%379 = fmul double %378, 1.000000e-03
br label %400
380: ; preds = %348
%381 = fcmp oeq double %364, 1.000000e+00
%382 = load double, double* %52
%383 = fadd double %382, 3.061000e+01
%384 = fmul double %383, 9.012000e-02
%385 = tail call double @exp(double %384)
%386 = load double, double* %52
%387 = fadd double %386, 2.384000e+01
%388 = fmul double %387, -1.190000e-01
%389 = tail call double @exp(double %388)
%390 = fmul double %389, 3.690000e-01
%391 = tail call double @llvm.fmuladd.f64(double %385, double 1.037000e+00, double %390)
br i1 %381, label %392, label %396
392: ; preds = %380
%393 = fdiv double 7.838000e+00, %391
%394 = fadd double %393, 1.191000e+00
%395 = fmul double %394, 2.500000e-03
br label %400
396: ; preds = %380
%397 = fdiv double 1.959000e+01, %391
%398 = fadd double %397, 2.980000e+00
%399 = fmul double %398, 1.000000e-03
br label %400
400: ; preds = %392, %396, %366
%401 = phi double [ %379, %366 ], [ %395, %392 ], [ %399, %396 ]
%402 = getelementptr inbounds double, double* %3, i64 161
store double %401, double* %402
%403 = load double, double* %363
%404 = getelementptr inbounds double, double* %1, i64 8
%405 = load double, double* %404
%406 = fsub double %403, %405
%407 = fdiv double %406, %401
%408 = getelementptr inbounds double, double* %2, i64 8
store double %407, double* %408
%409 = load double, double* %5
%410 = fcmp une double %409, 2.000000e+00
%411 = load double, double* %52
%412 = select i1 %410, double 1.420000e+01, double 1.320000e+01
%413 = fadd double %411, %412
%414 = fdiv double %413, -1.060000e+01
%415 = tail call double @exp(double %414)
%416 = fadd double %415, 1.000000e+00
%417 = fdiv double 1.000000e+00, %416
%418 = getelementptr inbounds double, double* %3, i64 164
store double %417, double* %418
%419 = load double, double* %5
%420 = fcmp une double %419, 2.000000e+00
%421 = select i1 %420, double -9.000000e+00, double -1.000000e+01
%422 = load double, double* %52
%423 = fadd double %422, %421
%424 = fdiv double %423, 1.590000e+01
%425 = tail call double @exp(double %424)
%426 = load double, double* %52
%427 = fadd double %426, %421
%428 = fdiv double %427, -2.250000e+01
%429 = tail call double @exp(double %428)
%430 = fmul double %429, 0x3FEEB851EB851EB8
%431 = tail call double @llvm.fmuladd.f64(double %425, double 3.720000e+01, double %430)
%432 = fdiv double 1.000000e+00, %431
%433 = getelementptr inbounds double, double* %3, i64 165
store double %432, double* %433
%434 = load double, double* %418
%435 = getelementptr inbounds double, double* %1, i64 9
%436 = load double, double* %435
%437 = fsub double %434, %436
%438 = fdiv double %437, %432
%439 = getelementptr inbounds double, double* %2, i64 9
store double %438, double* %439
%440 = load double, double* %418
%441 = getelementptr inbounds double, double* %3, i64 166
store double %440, double* %441
%442 = load double, double* %5
%443 = fcmp une double %442, 2.000000e+00
%444 = select i1 %443, double -9.000000e+00, double -1.000000e+01
%445 = load double, double* %52
%446 = fadd double %445, %444
%447 = fdiv double %446, 1.700000e+01
%448 = tail call double @exp(double %447)
%449 = load double, double* %52
%450 = fadd double %449, %444
%451 = fdiv double %450, -2.160000e+01
%452 = tail call double @exp(double %451)
%453 = fmul double %452, 1.500000e-01
%454 = tail call double @llvm.fmuladd.f64(double %448, double 4.200000e+00, double %453)
%455 = fdiv double 1.000000e+00, %454
%456 = getelementptr inbounds double, double* %3, i64 167
store double %455, double* %456
%457 = load double, double* %441
%458 = getelementptr inbounds double, double* %1, i64 10
%459 = load double, double* %458
%460 = fsub double %457, %459
%461 = fdiv double %460, %455
%462 = getelementptr inbounds double, double* %2, i64 10
store double %461, double* %462
%463 = load double, double* %52
%464 = fadd double %463, 1.860000e+01
%465 = fdiv double %464, 1.010000e+01
%466 = tail call double @exp(double %465)
%467 = fadd double %466, 1.000000e+00
%468 = fdiv double 1.000000e+00, %467
%469 = getelementptr inbounds double, double* %3, i64 169
store double %468, double* %469
%470 = getelementptr inbounds double, double* %1, i64 11
%471 = load double, double* %470
%472 = fsub double %468, %471
%473 = getelementptr inbounds double, double* %3, i64 168
%474 = load double, double* %473
%475 = fdiv double %472, %474
%476 = getelementptr inbounds double, double* %2, i64 11
store double %475, double* %476
%477 = load double, double* %52
%478 = fadd double %477, -4.000000e+01
%479 = fdiv double %478, -9.000000e+00
%480 = tail call double @exp(double %479)
%481 = fadd double %480, 1.000000e+00
%482 = fdiv double 1.400000e+01, %481
%483 = getelementptr inbounds double, double* %3, i64 172
store double %482, double* %483
%484 = load double, double* %52
%485 = fdiv double %484, -4.500000e+01
%486 = tail call double @exp(double %485)
%487 = getelementptr inbounds double, double* %3, i64 173
store double %486, double* %487
%488 = load double, double* %483
%489 = getelementptr inbounds double, double* %1, i64 12
%490 = load double, double* %489
%491 = fsub double 1.000000e+00, %490
%492 = fneg double %486
%493 = fmul double %490, %492
%494 = tail call double @llvm.fmuladd.f64(double %488, double %491, double %493)
%495 = getelementptr inbounds double, double* %2, i64 12
store double %494, double* %495
%496 = load double, double* %5
%497 = fcmp oeq double %496, 0.000000e+00
%498 = select i1 %497, double -2.662000e+01, double -2.663000e+01
%499 = load double, double* %52
%500 = fadd double %499, 7.891000e+01
%501 = fdiv double %500, %498
%502 = tail call double @exp(double %501)
%503 = getelementptr inbounds double, double* %3, i64 178
store double %502, double* %503
%504 = load double, double* %52
%505 = fadd double %504, 0x4052C851EB851EB8
%506 = fdiv double %505, 2.125000e+01
%507 = tail call double @exp(double %506)
%508 = getelementptr inbounds double, double* %3, i64 179
store double %507, double* %508
%509 = load double, double* %503
%510 = getelementptr inbounds double, double* %1, i64 13
%511 = load double, double* %510
%512 = fsub double 1.000000e+00, %511
%513 = fneg double %507
%514 = fmul double %511, %513
%515 = tail call double @llvm.fmuladd.f64(double %509, double %512, double %514)
%516 = getelementptr inbounds double, double* %2, i64 13
store double %515, double* %516
%517 = getelementptr inbounds double, double* %3, i64 117
%518 = load double, double* %517
%519 = getelementptr inbounds double, double* %3, i64 48
%520 = load double, double* %519
%521 = getelementptr inbounds double, double* %3, i64 103
%522 = load double, double* %521
%523 = fadd double %520, %522
%524 = fdiv double %520, %523
%525 = tail call double @pow(double %524, double 3.000000e+00)
%526 = fmul double %518, %525
%527 = getelementptr inbounds double, double* %3, i64 47
%528 = load double, double* %527
%529 = getelementptr inbounds double, double* %3, i64 102
%530 = load double, double* %529
%531 = fadd double %528, %530
%532 = fdiv double %528, %531
%533 = fmul double %532, %532
%534 = fmul double %526, %533
%535 = fmul double %534, 1.600000e+00
%536 = load double, double* %52
%537 = fadd double %536, 6.000000e+01
%538 = fdiv double %537, -4.000000e+01
%539 = tail call double @exp(double %538)
%540 = fadd double %539, 1.500000e+00
%541 = fdiv double %535, %540
%542 = getelementptr inbounds double, double* %3, i64 118
store double %541, double* %542
%543 = load double, double* %5
%544 = fcmp oeq double %543, 0.000000e+00
%545 = getelementptr inbounds double, double* %3, i64 115
%546 = load double, double* %545
%547 = load double, double* %519
%548 = tail call double @pow(double %547, double 3.000000e+00)
%549 = getelementptr inbounds double, double* %3, i64 45
%550 = load double, double* %549
%551 = fmul double %548, %550
%552 = load double, double* %52
%553 = fmul double %552, 3.743000e-02
%554 = getelementptr inbounds double, double* %3, i64 89
%555 = load double, double* %554
%556 = fmul double %553, %555
%557 = tail call double @exp(double %556)
%558 = getelementptr inbounds double, double* %3, i64 49
%559 = load double, double* %558
%560 = tail call double @pow(double %559, double 3.000000e+00)
%561 = getelementptr inbounds double, double* %3, i64 44
%562 = load double, double* %561
%563 = load double, double* %52
%564 = select i1 %544, double 3.740000e-02, double 3.743000e-02
%565 = fmul double %563, %564
%566 = load double, double* %554
%567 = fadd double %566, -1.000000e+00
%568 = fmul double %565, %567
%569 = tail call double @exp(double %568)
%570 = fneg double %560
%571 = fmul double %562, %570
%572 = fmul double %571, %569
%573 = tail call double @llvm.fmuladd.f64(double %551, double %557, double %572)
%574 = fmul double %546, %573
%575 = getelementptr inbounds double, double* %3, i64 88
%576 = load double, double* %575
%577 = load double, double* %561
%578 = load double, double* %558
%579 = tail call double @pow(double %578, double 3.000000e+00)
%580 = load double, double* %549
%581 = load double, double* %519
%582 = tail call double @pow(double %581, double 3.000000e+00)
%583 = fmul double %580, %582
%584 = tail call double @llvm.fmuladd.f64(double %577, double %579, double %583)
%585 = tail call double @llvm.fmuladd.f64(double %576, double %584, double 1.000000e+00)
%586 = fdiv double %574, %585
%587 = getelementptr inbounds double, double* %3, i64 116
store double %586, double* %587
%588 = load double, double* %5
%589 = fcmp une double %588, 2.000000e+00
%590 = getelementptr inbounds double, double* %3, i64 176
%591 = load double, double* %590
%592 = load double, double* %510
%593 = fmul double %591, %592
%594 = load double, double* %52
br i1 %589, label %595, label %610
595: ; preds = %400
%596 = getelementptr inbounds double, double* %3, i64 122
%597 = load double, double* %596
%598 = fsub double %594, %597
%599 = fmul double %593, %598
%600 = getelementptr inbounds double, double* %3, i64 177
store double %599, double* %600
%601 = getelementptr inbounds double, double* %3, i64 174
%602 = load double, double* %601
%603 = load double, double* %510
%604 = fmul double %602, %603
%605 = load double, double* %52
%606 = getelementptr inbounds double, double* %3, i64 121
%607 = load double, double* %606
%608 = fsub double %605, %607
%609 = fmul double %604, %608
br label %623
610: ; preds = %400
%611 = fadd double %594, 1.020000e+02
%612 = fmul double %593, %611
%613 = getelementptr inbounds double, double* %3, i64 177
store double %612, double* %613
%614 = getelementptr inbounds double, double* %3, i64 174
%615 = load double, double* %614
%616 = load double, double* %510
%617 = fmul double %615, %616
%618 = load double, double* %52
%619 = fadd double %618, -7.760000e+01
%620 = fmul double %617, %619
%621 = getelementptr inbounds double, double* %3, i64 122
%622 = load double, double* %621
br label %623
623: ; preds = %610, %595
%624 = phi double [ %597, %595 ], [ %622, %610 ]
%625 = phi double* [ %600, %595 ], [ %613, %610 ]
%626 = phi double [ %609, %595 ], [ %620, %610 ]
%627 = getelementptr inbounds double, double* %3, i64 175
store double %626, double* %627
%628 = getelementptr inbounds double, double* %3, i64 170
%629 = load double, double* %628
%630 = load double, double* %489
%631 = fmul double %630, %630
%632 = fmul double %629, %631
%633 = load double, double* %52
%634 = getelementptr inbounds double, double* %3, i64 124
%635 = load double, double* %634
%636 = fsub double %633, %635
%637 = fmul double %632, %636
%638 = getelementptr inbounds double, double* %3, i64 171
store double %637, double* %638
%639 = getelementptr inbounds double, double* %3, i64 155
%640 = load double, double* %639
%641 = load double, double* %404
%642 = fmul double %640, %641
%643 = load double, double* %52
%644 = fsub double %643, %624
%645 = fmul double %642, %644
%646 = getelementptr inbounds double, double* %3, i64 157
store double %645, double* %646
%647 = getelementptr inbounds double, double* %3, i64 154
%648 = load double, double* %647
%649 = load double, double* %352
%650 = fmul double %648, %649
%651 = load double, double* %404
%652 = fmul double %650, %651
%653 = load double, double* %52
%654 = fsub double %653, %624
%655 = fmul double %652, %654
%656 = getelementptr inbounds double, double* %3, i64 156
store double %655, double* %656
%657 = getelementptr inbounds double, double* %3, i64 144
%658 = load double, double* %657
%659 = load double, double* %242
%660 = fmul double %658, %659
%661 = load double, double* %284
%662 = fmul double %660, %661
%663 = load double, double* %52
%664 = getelementptr inbounds double, double* %3, i64 7
%665 = load double, double* %664
%666 = fsub double %663, %665
%667 = fmul double %662, %666
%668 = getelementptr inbounds double, double* %3, i64 145
store double %667, double* %668
%669 = getelementptr inbounds double, double* %3, i64 134
%670 = load double, double* %669
%671 = load double, double* %213
%672 = load double, double* %167
%673 = load double, double* %52
%674 = fadd double %673, 1.410000e+01
%675 = fdiv double %674, -6.000000e+00
%676 = tail call double @exp(double %675)
%677 = fadd double %676, 1.000000e+00
%678 = fdiv double 6.000000e-03, %677
%679 = tail call double @llvm.fmuladd.f64(double %671, double %672, double %678)
%680 = fmul double %670, %679
%681 = load double, double* %52
%682 = load double, double* %3
%683 = fsub double %681, %682
%684 = fmul double %683, %680
%685 = getelementptr inbounds double, double* %3, i64 135
store double %684, double* %685
%686 = load double, double* %5
%687 = fcmp oeq double %686, 0.000000e+00
%688 = load double, double* %52
%689 = fadd double %688, 3.440000e+01
br i1 %687, label %690, label %701
690: ; preds = %623
%691 = fmul double %689, -6.300000e-02
%692 = tail call double @exp(double %691)
%693 = fmul double %692, 9.520000e-02
%694 = load double, double* %52
%695 = fadd double %694, 6.370000e+01
%696 = fmul double %695, -2.250000e-01
%697 = tail call double @exp(double %696)
%698 = tail call double @llvm.fmuladd.f64(double %697, double 1.660000e+00, double 1.000000e+00)
%699 = fdiv double %693, %698
%700 = fadd double %699, 8.690000e-02
br label %712
701: ; preds = %623
%702 = fmul double %689, -6.306000e-02
%703 = tail call double @exp(double %702)
%704 = fmul double %703, 9.518000e-02
%705 = load double, double* %52
%706 = fadd double %705, 6.370000e+01
%707 = fmul double %706, -2.251000e-01
%708 = tail call double @exp(double %707)
%709 = tail call double @llvm.fmuladd.f64(double %708, double 1.662000e+00, double 1.000000e+00)
%710 = fdiv double %704, %709
%711 = fadd double %710, 0x3FB6410B630A9153
br label %712
712: ; preds = %701, %690
%713 = phi double [ %700, %690 ], [ %711, %701 ]
%714 = getelementptr inbounds double, double* %3, i64 122
%715 = getelementptr inbounds double, double* %3, i64 128
store double %713, double* %715
%716 = fsub double 1.000000e+00, %713
%717 = load double, double* %74
%718 = load double, double* %95
%719 = fmul double %713, %718
%720 = tail call double @llvm.fmuladd.f64(double %716, double %717, double %719)
%721 = getelementptr inbounds double, double* %3, i64 129
store double %720, double* %721
%722 = getelementptr inbounds double, double* %3, i64 125
%723 = load double, double* %722
%724 = load double, double* %1
%725 = tail call double @pow(double %724, double 3.000000e+00)
%726 = fmul double %723, %725
%727 = load double, double* %721
%728 = fmul double %726, %727
%729 = getelementptr inbounds double, double* %3, i64 49
%730 = load double, double* %729
%731 = fmul double %728, %730
%732 = getelementptr inbounds double, double* %3, i64 52
%733 = load double, double* %732
%734 = fmul double %733, %733
%735 = fmul double %731, %734
%736 = getelementptr inbounds double, double* %3, i64 54
%737 = load double, double* %736
%738 = getelementptr inbounds double, double* %3, i64 55
%739 = load double, double* %738
%740 = fmul double %737, %739
%741 = fdiv double %735, %740
%742 = load double, double* %52
%743 = getelementptr inbounds double, double* %3, i64 121
%744 = load double, double* %743
%745 = fsub double %742, %744
%746 = fmul double %733, %745
%747 = fdiv double %746, %740
%748 = tail call double @exp(double %747)
%749 = fadd double %748, -1.000000e+00
%750 = fmul double %741, %749
%751 = load double, double* %52
%752 = load double, double* %732
%753 = fmul double %751, %752
%754 = load double, double* %736
%755 = load double, double* %738
%756 = fmul double %754, %755
%757 = fdiv double %753, %756
%758 = tail call double @exp(double %757)
%759 = fadd double %758, -1.000000e+00
%760 = fdiv double %750, %759
%761 = load double, double* %52
%762 = fmul double %761, %760
%763 = getelementptr inbounds double, double* %3, i64 183
store double %762, double* %763
%764 = getelementptr inbounds double, double* %3, i64 113
%765 = load double, double* %764
%766 = load double, double* %52
%767 = load double, double* %714
%768 = fsub double %766, %767
%769 = fmul double %765, %768
%770 = getelementptr inbounds double, double* %3, i64 181
store double %769, double* %770
%771 = getelementptr inbounds double, double* %3, i64 114
%772 = load double, double* %771
%773 = load double, double* %52
%774 = getelementptr inbounds double, double* %3, i64 123
%775 = load double, double* %774
%776 = fsub double %773, %775
%777 = fmul double %772, %776
%778 = getelementptr inbounds double, double* %3, i64 182
store double %777, double* %778
%779 = getelementptr inbounds double, double* %3, i64 112
%780 = load double, double* %779
%781 = load double, double* %52
%782 = load double, double* %743
%783 = fsub double %781, %782
%784 = fmul double %780, %783
%785 = getelementptr inbounds double, double* %3, i64 180
store double %784, double* %785
%786 = load double, double* %435
%787 = load double, double* %458
%788 = fmul double %787, 4.000000e-01
%789 = tail call double @llvm.fmuladd.f64(double %786, double 6.000000e-01, double %788)
%790 = getelementptr inbounds double, double* %3, i64 163
store double %789, double* %790
%791 = getelementptr inbounds double, double* %3, i64 162
%792 = load double, double* %791
%793 = fmul double %792, %789
%794 = load double, double* %470
%795 = fmul double %793, %794
%796 = load double, double* %52
%797 = fsub double %796, %767
%798 = fmul double %795, %797
%799 = getelementptr inbounds double, double* %3, i64 184
store double %798, double* %799
%800 = getelementptr inbounds double, double* %3, i64 111
%801 = load double, double* %800
%802 = fdiv double -1.000000e+00, %801
%803 = load double, double* %685
%804 = fadd double %762, %803
%805 = load double, double* %668
%806 = fadd double %804, %805
%807 = load double, double* %656
%808 = fadd double %806, %807
%809 = load double, double* %646
%810 = fadd double %808, %809
%811 = fadd double %798, %810
%812 = load double, double* %638
%813 = fadd double %812, %811
%814 = load double, double* %627
%815 = fadd double %814, %813
%816 = load double, double* %625
%817 = fadd double %816, %815
%818 = fadd double %784, %817
%819 = fadd double %777, %818
%820 = fadd double %769, %819
%821 = load double, double* %587
%822 = fadd double %821, %820
%823 = load double, double* %542
%824 = fadd double %823, %822
%825 = getelementptr inbounds double, double* %3, i64 120
%826 = load double, double* %825
%827 = fadd double %826, %824
%828 = fmul double %802, %827
%829 = getelementptr inbounds double, double* %2, i64 14
store double %828, double* %829
ret void
}