#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 computeVariables(double voi, double *states, double *rates,
                      double *variables) {
  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[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[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;
  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[130] = 1.0 / (1.0 + exp((states[14] + 66.1) / 6.4));
  variables[131] = variables[130];
  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;
  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;
  variables[135] = variables[134] *
                   (states[4] * states[3] +
                    0.006 / (1.0 + exp(-(states[14] + 14.1) / 6.0))) *
                   (states[14] - variables[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]);
  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[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]);
  variables[143] = 1.0 / (1.0 + exp((states[14] + 45.0) / 5.0));
  variables[145] =
      variables[144] * states[5] * states[6] * (states[14] - variables[7]);
  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]);
  variables[149] = 1.0 / (1.0 + exp(-(states[14] + 37.0) / 6.8));
  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]);
  variables[153] = 1.0 / (1.0 + exp((states[14] + 71.0) / 9.0));
  variables[156] =
      variables[154] * states[7] * states[8] * (states[14] - variables[122]);
  variables[157] = variables[155] * states[8] * (states[14] - variables[122]);
  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)));
  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))));
  variables[163] = 0.6 * states[9] + 0.4 * states[10];
  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));
  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));
  variables[169] = 1.0 / (1.0 + exp((states[14] + 18.6) / 10.1));
  variables[171] =
      variables[170] * pow(states[12], 2.0) * (states[14] - variables[124]);
  variables[172] = 14.0 / (1.0 + exp(-(states[14] - 40.0) / 9.0));
  variables[173] = 1.0 * exp(-states[14] / 45.0);
  variables[175] =
      (variables[56] != 2.0)
          ? variables[174] * states[13] * (states[14] - variables[121])
          : variables[174] * states[13] * (states[14] - 77.6);
  variables[177] =
      (variables[56] != 2.0)
          ? variables[176] * states[13] * (states[14] - variables[122])
          : variables[176] * states[13] * (states[14] + 102.0);
  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);
  variables[180] = variables[112] * (states[14] - variables[121]);
  variables[181] = variables[113] * (states[14] - variables[122]);
  variables[182] = variables[114] * (states[14] - variables[123]);
  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[184] = variables[162] * variables[163] * states[11] *
                   (states[14] - variables[122]);
}


x86 assembly (clang, -O0):
<computeVariables>:
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    130c <computeVariables+0x1ec>
jp     130c <computeVariables+0x1ec>
mov    -0x20(%rbp),%rax
movsd  0x398(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x2e88(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x168(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2e6e(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2c8(%rax),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x2e37(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x160(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x2e25(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2c8(%rax),%xmm1
movsd  0x2df4(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm3
movaps %xmm0,%xmm4
movsd  -0x58(%rbp),%xmm0
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,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x2c0(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x160(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x2d76(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x168(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x2d47(%rip),%xmm1
call   1040 <pow@plt>
movsd  -0x50(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm4
movsd  -0x38(%rbp),%xmm1
movaps %xmm0,%xmm5
movsd  -0x30(%rbp),%xmm0
mulsd  %xmm5,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0x2d06(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    14e2 <computeVariables+0x3c2>
mov    -0x20(%rbp),%rax
movsd  0x398(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x2cd4(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x168(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2cb7(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x2c8(%rax),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x2c7d(%rip),%xmm1
call   1040 <pow@plt>
mov    -0x20(%rbp),%rax
mulsd  0x160(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2c60(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x2c8(%rax),%xmm1
movsd  0x2c37(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0xa0(%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,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x2c0(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x160(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x2baa(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x168(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x180(%rax),%xmm0
movsd  0x2b75(%rip),%xmm1
call   1040 <pow@plt>
movsd  -0x98(%rbp),%xmm3
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm4
ff
movsd  -0x80(%rbp),%xmm1
movaps %xmm0,%xmm5
movsd  -0x78(%rbp),%xmm0
mulsd  %xmm5,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0x2b2b(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3a0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x3a8(%rax),%xmm0
movsd  %xmm0,-0xd0(%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  0x2ad1(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%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  0x2abd(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x2a99(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2a79(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2a4d(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0x2a29(%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    168d <computeVariables+0x56d>
jp     168d <computeVariables+0x56d>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x29fe(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x299d(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2991(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x29cd(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    16f3 <computeVariables+0x5d3>
mov    -0x10(%rbp),%rax
movsd  0x29bf(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2993(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x2932(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x2926(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x2962(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3f0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17be <computeVariables+0x69e>
jp     17be <computeVariables+0x69e>
mov    -0x10(%rbp),%rax
movsd  0x299e(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2989(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2964(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x294f(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xe8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x292b(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x2917(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x28c7(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x28f3(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1851 <computeVariables+0x731>
mov    -0x10(%rbp),%rax
movsd  0x28ce(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x28b9(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2894(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x287f(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0xf0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x285b(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x2847(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x282f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x281b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x3f8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    191f <computeVariables+0x7ff>
jp     191f <computeVariables+0x7ff>
mov    -0x10(%rbp),%rax
movsd  0x2878(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2893(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x2877(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2827(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x284a(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  0x2826(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x2702(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0x2802(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    19b5 <computeVariables+0x895>
mov    -0x10(%rbp),%rax
movsd  0x27dd(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x27c8(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x27ac(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x278c(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2777(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
movsd  0x2753(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x2667(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0x272f(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x400(%rax)
mov    -0x20(%rbp),%rax
movsd  0x262b(%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    -0x10(%rbp),%rax
movsd  0x27ad(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x2798(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x25c7(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x25bb(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x410(%rax)
mov    -0x20(%rbp),%rax
movsd  0x410(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x418(%rax)
mov    -0x10(%rbp),%rax
movsd  0x273f(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x272a(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x270e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x26ee(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x26d9(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
movsd  0x26b5(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x2519(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0x2691(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x420(%rax)
mov    -0x10(%rbp),%rax
movsd  0x266d(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2658(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x263c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x261c(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2607(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x128(%rbp),%xmm0
ff
movsd  0x25e3(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x247f(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  0x25bf(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x428(%rax)
mov    -0x20(%rbp),%rax
movsd  0x430(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2565(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2539(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm3
ff
movaps %xmm0,%xmm2
movsd  -0x110(%rbp),%xmm0
ff
movsd  0x23cd(%rip),%xmm4
addsd  %xmm2,%xmm4
movsd  0x24f9(%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    1d73 <computeVariables+0xc53>
jp     1d73 <computeVariables+0xc53>
mov    -0x10(%rbp),%rax
movsd  0x254d(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2558(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2528(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x24fc(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x150(%rbp),%xmm0
ff
movsd  0x2300(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x24bc(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x249b(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x148(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x140(%rbp),%xmm0
ff
movsd  0x22a6(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
jmp    1f6a <computeVariables+0xe4a>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x2279(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1e7b <computeVariables+0xd5b>
jp     1e7b <computeVariables+0xd5b>
mov    -0x10(%rbp),%rax
movsd  0x2445(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x2448(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2420(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x23f4(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x170(%rbp),%xmm0
ff
movsd  0x21f8(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x23b4(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x2393(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x168(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x160(%rbp),%xmm0
ff
movsd  0x219e(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
jmp    1f5a <computeVariables+0xe3a>
mov    -0x10(%rbp),%rax
movsd  0x2361(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x235c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x233c(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2310(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x188(%rbp),%xmm0
ff
movsd  0x2114(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x22d0(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x22af(%rip),%xmm0
mulsd  0x70(%rax),%xmm0
call   1030 <exp@plt>
movsd  -0x180(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x178(%rbp),%xmm0
ff
movsd  0x20ba(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x440(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x206e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2019 <computeVariables+0xef9>
jp     2019 <computeVariables+0xef9>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x225d(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x2261(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x2234(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x2220(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x198(%rbp),%xmm0
ff
movsd  0x1ffc(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
jmp    208b <computeVariables+0xf6b>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x21e6(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x21e2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  0x21bd(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x21a9(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  0x1f85(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x190(%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  0x1f81(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x450(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    214c <computeVariables+0x102c>
jp     214c <computeVariables+0x102c>
mov    -0x10(%rbp),%rax
movsd  0x2146(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x2022(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1ed1(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1ec5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
jmp    2253 <computeVariables+0x1133>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1ea0(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    21ea <computeVariables+0x10ca>
jp     21ea <computeVariables+0x10ca>
mov    -0x10(%rbp),%rax
movsd  0x20bc(%rip),%xmm1
addsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x209b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1f84(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1e33(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1e27(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
jmp    2243 <computeVariables+0x1123>
mov    -0x10(%rbp),%rax
movsd  0x2032(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1f26(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1dd5(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1dc9(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x458(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1d85(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    22fa <computeVariables+0x11da>
jp     22fa <computeVariables+0x11da>
mov    -0x10(%rbp),%rax
movsd  0x1fb9(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1fbc(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1f94(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1f7f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  0x1d1b(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
jmp    2364 <computeVariables+0x1244>
mov    -0x10(%rbp),%rax
movsd  0x1f4a(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1f45(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1f25(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1f10(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  0x1cac(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x460(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1c74(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    23fa <computeVariables+0x12da>
jp     23fa <computeVariables+0x12da>
mov    -0x10(%rbp),%rax
movsd  0x1ea8(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1e7c(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1c23(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1e87(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
jmp    2453 <computeVariables+0x1333>
mov    -0x10(%rbp),%rax
movsd  0x1e4a(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1e1e(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1bc5(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1e21(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x468(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1b85(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    24d8 <computeVariables+0x13b8>
jp     24d8 <computeVariables+0x13b8>
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x1dd9(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1dd5(%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,-0x1d8(%rbp)
ff
jmp    2504 <computeVariables+0x13e4>
mov    -0x20(%rbp),%rax
movsd  0x460(%rax),%xmm1
mov    -0x20(%rbp),%rax
addsd  0x468(%rax),%xmm1
movsd  0x1b08(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x470(%rax)
mov    -0x10(%rbp),%rax
movsd  0x1d84(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1cdf(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1abe(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1ab2(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x478(%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    -0x10(%rbp),%rax
movsd  0x1cf6(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1cb9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1ccd(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x490(%rax)
mov    -0x10(%rbp),%rax
movsd  0x1cb9(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1c65(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1c79(%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  0x19b1(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4a0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x1c25(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1bf9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1960(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1954(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4a8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1930(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2751 <computeVariables+0x1631>
jp     2751 <computeVariables+0x1631>
mov    -0x10(%rbp),%rax
movsd  0x1be4(%rip),%xmm1
addsd  0x70(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x1bc3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1b8c(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1b70(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
jmp    27a1 <computeVariables+0x1681>
mov    -0x10(%rbp),%rax
movsd  0x1b63(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1b37(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1b1b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4b0(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1837(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2817 <computeVariables+0x16f7>
jp     2817 <computeVariables+0x16f7>
mov    -0x10(%rbp),%rax
movsd  0x1aeb(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1aee(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1ad2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
jmp    2850 <computeVariables+0x1730>
mov    -0x10(%rbp),%rax
movsd  0x1a9d(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1ab0(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1a94(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x1e8(%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  0x177c(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4c0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x1a30(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1a4b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1742(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1736(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4c8(%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  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    -0x10(%rbp),%rax
movsd  0x198d(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x1978(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x167f(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1673(%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    2a54 <computeVariables+0x1934>
jp     2a54 <computeVariables+0x1934>
mov    -0x10(%rbp),%rax
movsd  0x19c8(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x19b3(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x1997(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1913(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x18ff(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x195f(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x194a(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x1f8(%rbp),%xmm1
ff
movsd  0x1929(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
jmp    2c1f <computeVariables+0x1aff>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1598(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2b7c <computeVariables+0x1a5c>
jp     2b7c <computeVariables+0x1a5c>
mov    -0x10(%rbp),%rax
movsd  0x18b4(%rip),%xmm0
addsd  0x70(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm1
movsd  0x18bb(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1883(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm0
movsd  0x188e(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1842(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0x1516(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x182e(%rip),%xmm2
addsd  0x70(%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x370(%rax),%xmm1
movsd  0x1845(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x208(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x17e1(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x17cd(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x17fd(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x17e9(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x17d5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
jmp    2c0f <computeVariables+0x1aef>
mov    -0x10(%rbp),%rax
movsd  0x17b0(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x179b(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1776(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1761(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x210(%rbp),%xmm0
ff
movsd  0x173d(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1729(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1711(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x16fd(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x200(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x4f8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x175c(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1731(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1388(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x137c(%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    2d57 <computeVariables+0x1c37>
jp     2d57 <computeVariables+0x1c37>
mov    -0x10(%rbp),%rax
movsd  0x1729(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x174c(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x16ef(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x171a(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x220(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x16b6(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x16a2(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x16da(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x1676(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1662(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
jmp    2ece <computeVariables+0x1dae>
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1295(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2e1f <computeVariables+0x1cff>
jp     2e1f <computeVariables+0x1cff>
mov    -0x10(%rbp),%rax
movsd  0x1661(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x164c(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1627(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x1612(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x230(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x15ee(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x15da(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x160a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x15f6(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x15e2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
jmp    2ebe <computeVariables+0x1d9e>
mov    -0x10(%rbp),%rax
movsd  0x15bd(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x15a8(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x1583(%rip),%xmm1
addsd  0x70(%rax),%xmm1
movsd  0x156e(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x238(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x154a(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1536(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x151e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x150a(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x14f6(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x218(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x508(%rax)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x1311(%rip),%xmm1
mulsd  0x50(%rax),%xmm1
movsd  0x151c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x518(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1114(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2f41 <computeVariables+0x1e21>
jp     2f41 <computeVariables+0x1e21>
jmp    2f9f <computeVariables+0x1e7f>
mov    -0x10(%rbp),%rax
movsd  0x14eb(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x14b7(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x107e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1072(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
jmp    2ff8 <computeVariables+0x1ed8>
mov    -0x10(%rbp),%rax
movsd  0x1485(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1459(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0x1020(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1014(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x240(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x520(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1020(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3035 <computeVariables+0x1f15>
jp     3035 <computeVariables+0x1f15>
jmp    30e0 <computeVariables+0x1fc0>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x12b2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x1406(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x1284(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x13b9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x250(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1395(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1381(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xf31(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
jmp    3186 <computeVariables+0x2066>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x1267(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x135b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x1239(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x130e(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x258(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x12ea(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x12d6(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe86(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x528(%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  0xe7a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    31db <computeVariables+0x20bb>
jp     31db <computeVariables+0x20bb>
jmp    3286 <computeVariables+0x2166>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x110c(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x1280(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x268(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x10de(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1233(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x268(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x120f(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x11fb(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd8b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
jmp    332c <computeVariables+0x220c>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x10c1(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x11d5(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x270(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x1093(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1188(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  -0x270(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  0x1164(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x1150(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xce0(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x260(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x538(%rax)
mov    -0x10(%rbp),%rax
movsd  0x1144(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0x112f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0xc96(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xc8a(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x548(%rax)
mov    -0x20(%rbp),%rax
movsd  0x550(%rax),%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  0xc95(%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    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0xc33(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xee0(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movsd  0xbd7(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x104b(%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  0xe3b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0xb7f(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x568(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xb9b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    34ba <computeVariables+0x239a>
jp     34ba <computeVariables+0x239a>
jmp    34f5 <computeVariables+0x23d5>
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,-0x280(%rbp)
ff
jmp    352b <computeVariables+0x240b>
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  0xf7d(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x280(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x578(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xaed(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3568 <computeVariables+0x2448>
jp     3568 <computeVariables+0x2448>
jmp    35a3 <computeVariables+0x2483>
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,-0x288(%rbp)
ff
jmp    35d5 <computeVariables+0x24b5>
mov    -0x20(%rbp),%rax
movsd  0x580(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xedc(%rip),%xmm1
addsd  0x70(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x288(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x588(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    365d <computeVariables+0x253d>
jp     365d <computeVariables+0x253d>
mov    -0x10(%rbp),%rax
movsd  0xe9c(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xe80(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x9b4(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
jmp    36ad <computeVariables+0x258d>
mov    -0x10(%rbp),%rax
movsd  0xe47(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xe1b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x95f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x290(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x590(%rax)
mov    -0x10(%rbp),%rax
movsd  0xdfb(%rip),%xmm0
addsd  0x70(%rax),%xmm0
movsd  0xde6(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  0x912(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x598(%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    -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  0x3e8(%rax),%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x853(%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  0x843(%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  0x776(%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  0x71d(%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  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)
add    $0x2b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeVariables>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdx,%rbx
mov    %rdi,%r14
xorpd  %xmm1,%xmm1
movsd  0x1c0(%rdx),%xmm0
cmpeqsd %xmm1,%xmm0
movq   %xmm0,%r12
and    $0x1,%r12d
movsd  0x398(%rdx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x180(%rdx),%xmm0
movsd  0x1e97(%rip),%xmm1
call   1040 <pow@plt>
mulsd  0x168(%rbx),%xmm0
movsd  %xmm0,0x28(%rsp)
lea    0x70(%r14),%r15
movsd  0x70(%r14),%xmm0
mulsd  0x1e7a(%rip),%xmm0
mulsd  0x2c8(%rbx),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x188(%rbx),%xmm0
movsd  0x1e4f(%rip),%xmm1
call   1040 <pow@plt>
movsd  0x70(%r14),%xmm2
lea    0x22fd(%rip),%rax
mulsd  (%rax,%r12,8),%xmm2
movsd  0x2c8(%rbx),%xmm1
addsd  0x1e37(%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  0x1dbe(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x168(%rbx),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x180(%rbx),%xmm0
movsd  0x1d95(%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  0x1d84(%rip),%xmm1
movsd  0x8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x3a0(%rbx)
movsd  0x3a8(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x180(%rbx),%xmm0
movsd  0x338(%rbx),%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm0
movsd  0x1d2c(%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  0x1d19(%rip),%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0x70(%r14),%xmm0
addsd  0x1d0d(%rip),%xmm0
divsd  0x1d0d(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1d08(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x3b0(%rbx)
movsd  0x70(%r14),%xmm1
movsd  0x1cf0(%rip),%xmm2
addsd  %xmm1,%xmm2
movsd  0x1c0(%rbx),%xmm0
cmpeqsd 0x214b(%rip),%xmm0
andpd  %xmm0,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
divsd  0x1ccf(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1c92(%rip),%xmm2
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm2
movsd  0x1cba(%rip),%xmm1
movapd %xmm2,%xmm0
call   1040 <pow@plt>
movsd  %xmm0,0x3f0(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd 0x20f9(%rip),%xmm0
movsd  0x70(%r14),%xmm0
jne    141a <computeVariables+0x2fa>
jp     141a <computeVariables+0x2fa>
addsd  0x1cc7(%rip),%xmm0
mulsd  0x1cc7(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x1cb7(%rip),%xmm0
mulsd  0x1cb7(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm2
mulsd  0x1cac(%rip),%xmm0
mulsd  0x1cac(%rip),%xmm2
addsd  %xmm0,%xmm2
movsd  0x1ca8(%rip),%xmm0
jmp    1471 <computeVariables+0x351>
addsd  0x1c36(%rip),%xmm0
mulsd  0x1c36(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x1c26(%rip),%xmm0
mulsd  0x1c26(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm2
mulsd  0x1c1b(%rip),%xmm0
mulsd  0x1c1b(%rip),%xmm2
addsd  %xmm0,%xmm2
movsd  0x1c17(%rip),%xmm0
movsd  0x1c4f(%rip),%xmm1
divsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x3f8(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movsd  (%r15),%xmm0
addsd  0x1c2a(%rip),%xmm0
jne    1503 <computeVariables+0x3e3>
jp     1503 <computeVariables+0x3e3>
mulsd  0x1c56(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1c51(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x1c16(%rip),%xmm0
mulsd  0x1c3e(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x1c33(%rip),%xmm0
addsd  0x1b23(%rip),%xmm0
divsd  %xmm0,%xmm1
addsd  0x1c27(%rip),%xmm1
jmp    155a <computeVariables+0x43a>
mulsd  0x1bcd(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1bc8(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x1bbd(%rip),%xmm0
mulsd  0x1bbd(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x1bb2(%rip),%xmm0
addsd  0x1aca(%rip),%xmm0
divsd  %xmm0,%xmm1
addsd  0x1ba6(%rip),%xmm1
movsd  %xmm1,0x400(%rbx)
movsd  0x1aae(%rip),%xmm0
subsd  %xmm1,%xmm0
mulsd  0x10(%r14),%xmm1
mulsd  0x8(%r14),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x408(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x1b9c(%rip),%xmm0
divsd  0x1b9c(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1a6f(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x410(%rbx)
movsd  %xmm1,0x418(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x1b71(%rip),%xmm0
mulsd  0x1b71(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1b6c(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r14),%xmm0
addsd  0x1b60(%rip),%xmm0
mulsd  0x1b60(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1b5b(%rip),%xmm0
addsd  0x1a03(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  0x1b49(%rip),%xmm1
movsd  %xmm1,0x420(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x1b3b(%rip),%xmm0
mulsd  0x1b3b(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1b36(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%r14),%xmm0
addsd  0x1b2a(%rip),%xmm0
mulsd  0x1b2a(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1b25(%rip),%xmm0
addsd  0x1995(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  0x1b13(%rip),%xmm1
movsd  %xmm1,0x428(%rbx)
movsd  0x430(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x20(%r14),%xmm1
movsd  0x70(%r14),%xmm0
addsd  0x1af1(%rip),%xmm0
divsd  0x1af1(%rip),%xmm0
mulsd  0x18(%r14),%xmm1
movsd  %xmm1,0x10(%rsp)
call   1030 <exp@plt>
addsd  0x1938(%rip),%xmm0
movsd  0x1ad8(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x10(%rsp),%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  0x70(%r14),%xmm0
subsd  (%rbx),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x438(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1739 <computeVariables+0x619>
jp     1739 <computeVariables+0x619>
movsd  (%r15),%xmm0
addsd  0x1a99(%rip),%xmm0
movsd  0x1aa9(%rip),%xmm1
jmp    1764 <computeVariables+0x644>
ucomisd 0x18d7(%rip),%xmm0
movsd  (%r15),%xmm0
addsd  0x1a7a(%rip),%xmm0
jne    175c <computeVariables+0x63c>
jp     175c <computeVariables+0x63c>
movsd  0x1a7e(%rip),%xmm1
jmp    1764 <computeVariables+0x644>
movsd  0x1a6c(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
divsd  0x1a72(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x188d(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  (%r15),%xmm0
movsd  0x1a50(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mulsd  0x1a46(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x1851(%rip),%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
addsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x440(%rbx)
movsd  0x1c0(%rbx),%xmm0
cmpeqsd 0x1830(%rip),%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  (%r15),%xmm0
addsd  0x1a03(%rip),%xmm0
lea    0x1ccc(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0x19ed(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x17e8(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x448(%rbx)
addsd  0x440(%rbx),%xmm1
movsd  0x19c6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x450(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1879 <computeVariables+0x759>
jp     1879 <computeVariables+0x759>
movsd  (%r15),%xmm0
addsd  0x19b9(%rip),%xmm0
jmp    18b4 <computeVariables+0x794>
ucomisd 0x1797(%rip),%xmm0
movsd  (%r15),%xmm1
jne    18a8 <computeVariables+0x788>
jp     18a8 <computeVariables+0x788>
addsd  0x198e(%rip),%xmm1
movsd  0x370(%rbx),%xmm0
mulsd  0x1986(%rip),%xmm0
addsd  %xmm1,%xmm0
jmp    18b4 <computeVariables+0x794>
addsd  0x1968(%rip),%xmm1
movapd %xmm1,%xmm0
divsd  0x18fc(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x174f(%rip),%xmm2
addsd  %xmm2,%xmm0
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x458(%rbx)
movsd  0x1c0(%rbx),%xmm0
cmpeqsd %xmm2,%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  (%r15),%xmm0
addsd  0x1939(%rip),%xmm0
lea    0x1bda(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0x1923(%rip),%xmm0
call   1030 <exp@plt>
addsd  0x16e6(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x460(%rbx)
movsd  0x1c0(%rbx),%xmm0
cmpeqsd 0x16cb(%rip),%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
lea    0x1b94(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x18c9(%rip),%xmm0
addsd  (%r15),%xmm0
mulsd  0x18cc(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x8(%rsp),%xmm2
movsd  0x1689(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm2
movsd  %xmm2,0x468(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd %xmm1,%xmm0
movapd %xmm1,%xmm0
jne    19cb <computeVariables+0x8ab>
jp     19cb <computeVariables+0x8ab>
movsd  0x370(%rbx),%xmm0
mulsd  0x188d(%rip),%xmm0
addsd  0x188d(%rip),%xmm0
addsd  0x460(%rbx),%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0x470(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x1873(%rip),%xmm0
divsd  0x1873(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1616(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x478(%rbx)
movsd  0x480(%rbx),%xmm0
mulsd  0x28(%r14),%xmm0
mulsd  0x30(%r14),%xmm0
movsd  0x70(%r14),%xmm1
subsd  0x38(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x488(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x1825(%rip),%xmm0
divsd  0x1825(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1820(%rip),%xmm0
movsd  %xmm0,0x490(%rbx)
movsd  0x1800(%rip),%xmm0
addsd  0x70(%r14),%xmm0
divsd  0x180a(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x17f5(%rip),%xmm0
movsd  %xmm0,0x498(%rbx)
addsd  0x490(%rbx),%xmm0
movsd  0x1575(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4a0(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x17d3(%rip),%xmm0
divsd  0x17d3(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1546(%rip),%xmm2
addsd  %xmm2,%xmm0
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4a8(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd %xmm2,%xmm0
movsd  0x70(%r14),%xmm1
jne    1b1a <computeVariables+0x9fa>
jp     1b1a <computeVariables+0x9fa>
addsd  0x17a4(%rip),%xmm1
movsd  0x370(%rbx),%xmm0
mulsd  0x179c(%rip),%xmm0
addsd  %xmm1,%xmm0
jmp    1b26 <computeVariables+0xa06>
addsd  0x177e(%rip),%xmm1
movapd %xmm1,%xmm0
divsd  0x178a(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1785(%rip),%xmm0
movsd  %xmm0,0x4b0(%rbx)
movsd  0x1c0(%rbx),%xmm0
cmpeqsd 0x14c4(%rip),%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  0x70(%r14),%xmm0
lea    0x1997(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
divsd  0x1752(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x174d(%rip),%xmm0
movsd  %xmm0,0x4b8(%rbx)
addsd  0x4b0(%rbx),%xmm0
movsd  0x147d(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4c0(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x16f3(%rip),%xmm0
divsd  0x171b(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x144e(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4c8(%rbx)
movsd  0x3d0(%rbx),%xmm0
movsd  0x4d0(%rbx),%xmm1
mulsd  0x38(%r14),%xmm1
mulsd  0x40(%r14),%xmm1
movsd  0x70(%r14),%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x4e0(%rbx)
movsd  0x4d8(%rbx),%xmm1
mulsd  0x40(%r14),%xmm1
movsd  0x70(%r14),%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x4e8(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x16a2(%rip),%xmm0
divsd  0x16a2(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x13c5(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x4f0(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ce0 <computeVariables+0xbc0>
jp     1ce0 <computeVariables+0xbc0>
movsd  (%r15),%xmm0
addsd  0x16cc(%rip),%xmm0
mulsd  0x16cc(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x16c7(%rip),%xmm0
movsd  0x167f(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x167b(%rip),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x16a8(%rip),%xmm0
mulsd  0x16a8(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x16a3(%rip),%xmm0
addsd  0x8(%rsp),%xmm0
jmp    1e01 <computeVariables+0xce1>
ucomisd 0x1330(%rip),%xmm0
movsd  (%r15),%xmm0
addsd  0x15fb(%rip),%xmm0
jne    1da6 <computeVariables+0xc86>
jp     1da6 <computeVariables+0xc86>
movsd  0x370(%rbx),%xmm1
mulsd  0x161f(%rip),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x15db(%rip),%xmm1
movapd %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x15c7(%rip),%xmm0
movsd  0x370(%rbx),%xmm1
unpcklpd %xmm1,%xmm1
movapd 0x17c3(%rip),%xmm2
mulpd  0x17cb(%rip),%xmm1
unpcklpd %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x159a(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x1594(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x15a8(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x15a4(%rip),%xmm0
mulsd  0x15a4(%rip),%xmm0
jmp    1e01 <computeVariables+0xce1>
mulsd  0x154a(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x153a(%rip),%xmm0
mulsd  0x153a(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1535(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x152f(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x152b(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1527(%rip),%xmm0
movsd  %xmm0,0x4f8(%rbx)
movsd  (%r15),%xmm0
addsd  0x156a(%rip),%xmm0
divsd  0x156a(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x11ed(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x500(%rbx)
movsd  0x1c0(%rbx),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    1ec4 <computeVariables+0xda4>
jp     1ec4 <computeVariables+0xda4>
movsd  (%r15),%xmm0
addsd  0x1534(%rip),%xmm0
mulsd  0x158c(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%r15),%xmm0
addsd  0x1524(%rip),%xmm0
mulsd  0x1574(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x151f(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x1519(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x1555(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1511(%rip),%xmm0
mulsd  0x1511(%rip),%xmm0
jmp    1f54 <computeVariables+0xe34>
movsd  (%r15),%xmm0
addsd  0x14bf(%rip),%xmm0
mulsd  0x14bf(%rip),%xmm0
movsd  %xmm1,0x8(%rsp)
call   1030 <exp@plt>
movsd  %xmm0,0x10(%rsp)
movsd  (%r15),%xmm0
addsd  0x14a9(%rip),%xmm0
mulsd  0x14a9(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x10(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
ucomisd 0x1100(%rip),%xmm2
mulsd  0x1490(%rip),%xmm0
mulsd  0x1490(%rip),%xmm1
addsd  %xmm0,%xmm1
jne    243c <computeVariables+0x131c>
jp     243c <computeVariables+0x131c>
movsd  0x1498(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  0x1494(%rip),%xmm0
mulsd  0x1494(%rip),%xmm0
movsd  %xmm0,0x508(%rbx)
movsd  0x48(%r14),%xmm0
movsd  0x50(%r14),%xmm1
mulsd  0x1298(%rip),%xmm1
mulsd  0x1490(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x518(%rbx)
movsd  0x1c0(%rbx),%xmm0
movsd  0x127c(%rip),%xmm1
cmpneqsd %xmm1,%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
movsd  0x70(%r14),%xmm0
lea    0x1582(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
divsd  0x1455(%rip),%xmm0
call   1030 <exp@plt>
movsd  0x1050(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x520(%rbx)
movsd  0x1c0(%rbx),%xmm2
cmpneqsd 0x1227(%rip),%xmm2
movsd  0x1427(%rip),%xmm1
movapd %xmm2,%xmm0
andpd  %xmm1,%xmm0
movsd  0x141f(%rip),%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,0x10(%rsp)
movsd  0x70(%r14),%xmm0
addsd  %xmm2,%xmm0
divsd  0x1407(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movapd 0x10(%rsp),%xmm0
addsd  0x70(%r14),%xmm0
divsd  0x13f0(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x13eb(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x13e5(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xfb1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x528(%rbx)
movsd  0x520(%rbx),%xmm0
movsd  %xmm0,0x530(%rbx)
movsd  0x1c0(%rbx),%xmm2
cmpneqsd 0x117c(%rip),%xmm2
movapd %xmm2,%xmm0
movsd  0x1378(%rip),%xmm1
andpd  %xmm1,%xmm0
movsd  0x1374(%rip),%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,0x10(%rsp)
movsd  0x70(%r14),%xmm0
addsd  %xmm2,%xmm0
divsd  0x137c(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movapd 0x10(%rsp),%xmm0
addsd  0x70(%r14),%xmm0
divsd  0x1365(%rip),%xmm0
call   1030 <exp@plt>
mulsd  0x1360(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x135a(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xf06(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x538(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x133c(%rip),%xmm0
divsd  0x133c(%rip),%xmm0
call   1030 <exp@plt>
movsd  0xed7(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x548(%rbx)
movsd  0x60(%r14),%xmm0
movsd  0x70(%r14),%xmm1
mulsd  %xmm0,%xmm0
mulsd  0x550(%rbx),%xmm0
subsd  0x3e0(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x558(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0xea5(%rip),%xmm0
movsd  0x1285(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
addsd  0xe74(%rip),%xmm0
movsd  0x12cc(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x560(%rbx)
movsd  0x70(%r14),%xmm0
divsd  0x12ba(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x568(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd 0x102d(%rip),%xmm0
movsd  0x570(%rbx),%xmm1
mulsd  0x68(%r14),%xmm1
movsd  0x70(%r14),%xmm2
jne    21fb <computeVariables+0x10db>
jnp    222d <computeVariables+0x110d>
subsd  0x3c8(%rbx),%xmm2
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x578(%rbx)
movsd  0x580(%rbx),%xmm2
mulsd  0x68(%r14),%xmm2
movsd  0x70(%r14),%xmm1
subsd  0x3d0(%rbx),%xmm1
jmp    225d <computeVariables+0x113d>
addsd  0x1253(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x578(%rbx)
movsd  0x580(%rbx),%xmm2
mulsd  0x68(%r14),%xmm2
movsd  0x70(%r14),%xmm1
addsd  0x1233(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x588(%rbx)
xorpd  %xmm1,%xmm1
cmpeqsd %xmm1,%xmm0
movq   %xmm0,%rax
movsd  0x70(%r14),%xmm0
addsd  0x1213(%rip),%xmm0
and    $0x1,%eax
lea    0x12b1(%rip),%rcx
divsd  (%rcx,%rax,8),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x590(%rbx)
movsd  0x70(%r14),%xmm0
addsd  0x11f1(%rip),%xmm0
divsd  0x11f1(%rip),%xmm0
call   1030 <exp@plt>
movsd  %xmm0,0x598(%rbx)
movsd  0x70(%r14),%xmm0
subsd  0x3c8(%rbx),%xmm0
mulsd  0x380(%rbx),%xmm0
movsd  %xmm0,0x5a0(%rbx)
movsd  0x70(%r14),%xmm0
subsd  0x3d0(%rbx),%xmm0
mulsd  0x388(%rbx),%xmm0
movsd  %xmm0,0x5a8(%rbx)
movsd  0x70(%r14),%xmm0
subsd  0x3d8(%rbx),%xmm0
mulsd  0x390(%rbx),%xmm0
movsd  %xmm0,0x5b0(%rbx)
movsd  0x3e8(%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r14),%xmm0
movsd  0xcc7(%rip),%xmm1
call   1040 <pow@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x408(%rbx),%xmm0
mulsd  0x188(%rbx),%xmm0
movsd  0x1a0(%rbx),%xmm2
movsd  0x70(%r14),%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  0xc67(%rip),%xmm0
addsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x70(%r14),%xmm0
mulsd  0x1a0(%rbx),%xmm0
movsd  0x1b0(%rbx),%xmm1
mulsd  0x1b8(%rbx),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
addsd  0xc28(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
mulsd  0x70(%r14),%xmm1
movsd  %xmm1,0x5b8(%rbx)
movsd  0x510(%rbx),%xmm0
mulsd  0x518(%rbx),%xmm0
mulsd  0x58(%r14),%xmm0
movsd  0x70(%r14),%xmm1
subsd  0x3d0(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x5c0(%rbx)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
movsd  0xf7c(%rip),%xmm0
jmp    1eab <computeVariables+0xd8b>

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

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