#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 log(double);
void computeComputedConstants(double *variables) {
  variables[110] =
      (variables[56] == 0.0)
          ? 1.07 * (3.0 * variables[57] - 0.1) /
                (3.0 *
                 (1.0 + 0.7745 * exp(-(3.0 * variables[57] - 2.05) / 0.295)))
      : (variables[56] == 1.0)
          ? variables[53] * variables[57] /
                (1.0 + 0.7745 * exp(-(3.0 * variables[57] - 2.05) / 0.295))
          : 1.07 * 29.0 * variables[57] /
                (30.0 *
                 (1.0 + 0.7745 * exp(-(29.0 * variables[57] - 24.5) / 1.95)));
  variables[111] =
      variables[50] + variables[110] * (variables[51] - variables[50]);
  variables[112] =
      (variables[56] == 0.0)
          ? variables[84] + variables[110] * (variables[87] - variables[84])
      : (variables[56] == 1.0)
          ? variables[82] + variables[110] * (variables[85] - variables[82])
          : variables[83] + variables[110] * (variables[86] - variables[83]);
  variables[113] =
      (variables[56] == 0.0)
          ? variables[66] + variables[110] * (variables[69] - variables[66])
      : (variables[56] == 1.0)
          ? variables[64] + variables[110] * (variables[67] - variables[64])
          : variables[65] + variables[110] * (variables[68] - variables[65]);
  variables[114] =
      (variables[56] == 0.0)
          ? variables[16] + variables[110] * (variables[19] - variables[16])
      : (variables[56] == 1.0)
          ? variables[14] + variables[110] * (variables[17] - variables[14])
          : variables[15] + variables[110] * (variables[18] - variables[15]);
  variables[115] =
      (variables[56] == 0.0)
          ? variables[92] + variables[110] * (variables[95] - variables[92])
      : (variables[56] == 1.0)
          ? variables[90] + variables[110] * (variables[93] - variables[90])
          : variables[91] + variables[110] * (variables[94] - variables[91]);
  variables[117] =
      (variables[56] == 0.0)
          ? variables[106] + variables[110] * (variables[109] - variables[106])
      : (variables[56] == 1.0)
          ? variables[104] + variables[110] * (variables[107] - variables[104])
          : variables[105] + variables[110] * (variables[108] - variables[105]);
  variables[119] =
      (variables[56] == 0.0)
          ? variables[60] + variables[110] * (variables[63] - variables[60])
      : (variables[56] == 1.0)
          ? variables[58] + variables[110] * (variables[61] - variables[58])
          : variables[59] + variables[110] * (variables[62] - variables[59]);
  variables[120] = variables[119] * variables[44] / (variables[44] + 0.0004);
  variables[121] = variables[54] * variables[55] / variables[52] *
                   log(variables[49] / variables[48]);
  variables[122] = variables[54] * variables[55] / variables[52] *
                   log(variables[47] / variables[46]);
  variables[123] = variables[54] * variables[55] / (2.0 * variables[52]) *
                   log(variables[45] / variables[44]);
  variables[124] = (variables[56] == 0.0)
                       ? variables[54] * variables[55] / variables[52] *
                             log((variables[47] + 0.12 * variables[49]) /
                                 (variables[46] + 0.12 * variables[48]))
                       : variables[54] * variables[55] / variables[52] *
                             log((variables[47] + 0.03 * variables[49]) /
                                 (variables[46] + 0.03 * variables[48]));
  variables[125] =
      (variables[56] == 0.0)
          ? variables[98] + variables[110] * (variables[101] - variables[98])
      : (variables[56] == 1.0)
          ? variables[96] + variables[110] * (variables[99] - variables[96])
          : variables[97] + variables[110] * (variables[100] - variables[97]);
  variables[134] =
      (variables[56] == 0.0)
          ? variables[3] + variables[110] * (variables[6] - variables[3])
      : (variables[56] == 1.0)
          ? variables[1] + variables[110] * (variables[4] - variables[1])
          : variables[2] + variables[110] * (variables[5] - variables[2]);
  variables[144] =
      (variables[56] == 0.0)
          ? variables[10] + variables[110] * (variables[13] - variables[10])
      : (variables[56] == 1.0)
          ? variables[8] + variables[110] * (variables[11] - variables[8])
          : variables[9] + variables[110] * (variables[12] - variables[9]);
  variables[154] =
      (variables[56] == 0.0)
          ? variables[28] + variables[110] * (variables[31] - variables[28])
      : (variables[56] == 1.0)
          ? variables[26] + variables[110] * (variables[29] - variables[26])
          : variables[27] + variables[110] * (variables[30] - variables[27]);
  variables[155] =
      (variables[56] == 0.0)
          ? variables[22] + variables[110] * (variables[25] - variables[22])
      : (variables[56] == 1.0)
          ? variables[20] + variables[110] * (variables[23] - variables[20])
          : variables[21] + variables[110] * (variables[24] - variables[21]);
  variables[162] =
      (variables[56] == 0.0)
          ? variables[72] + variables[110] * (variables[75] - variables[72])
      : (variables[56] == 1.0)
          ? variables[70] + variables[110] * (variables[73] - variables[70])
          : variables[71] + variables[110] * (variables[74] - variables[71]);
  variables[168] = (variables[56] == 0.0)   ? 0.002
                   : (variables[56] == 1.0) ? 0.002
                                            : 0.006;
  variables[170] =
      (variables[56] == 0.0)
          ? variables[78] + variables[110] * (variables[81] - variables[78])
      : (variables[56] == 1.0)
          ? variables[76] + variables[110] * (variables[79] - variables[76])
          : variables[77] + variables[110] * (variables[80] - variables[77]);
  variables[174] =
      (variables[56] == 0.0)
          ? variables[40] + variables[110] * (variables[43] - variables[40])
      : (variables[56] == 1.0)
          ? variables[38] + variables[110] * (variables[41] - variables[38])
          : variables[39] + variables[110] * (variables[42] - variables[39]);
  variables[176] =
      (variables[56] == 0.0)
          ? variables[34] + variables[110] * (variables[37] - variables[34])
      : (variables[56] == 1.0)
          ? variables[32] + variables[110] * (variables[35] - variables[32])
          : variables[33] + variables[110] * (variables[36] - variables[33]);
}


x86 assembly (clang, -O0):
<computeComputedConstants>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1209 <computeComputedConstants+0xe9>
jp     1209 <computeComputedConstants+0xe9>
mov    -0x8(%rbp),%rax
movsd  0x1c8(%rax),%xmm1
movsd  0x1ede(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x1eea(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x1ed6(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x1c8(%rax),%xmm0
movsd  0x1ea9(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1ea5(%rip),%xmm1
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1e72(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x18(%rbp),%xmm0
movsd  0x1e31(%rip),%xmm1
mulsd  %xmm1,%xmm2
movsd  0x1e15(%rip),%xmm1
addsd  %xmm1,%xmm2
movsd  0x1e49(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    1368 <computeComputedConstants+0x248>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1de3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    12c4 <computeComputedConstants+0x1a4>
jp     12c4 <computeComputedConstants+0x1a4>
mov    -0x8(%rbp),%rax
movsd  0x1a8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x1c8(%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x1c8(%rax),%xmm0
movsd  0x1de2(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1dde(%rip),%xmm1
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1dab(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0x1d6a(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1d4e(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    135e <computeComputedConstants+0x23e>
mov    -0x8(%rbp),%rax
movsd  0x1d60(%rip),%xmm0
mulsd  0x1c8(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x1c8(%rax),%xmm0
movsd  0x1d2f(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1d2b(%rip),%xmm1
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1cf8(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm2
movsd  -0x30(%rbp),%xmm0
movsd  0x1cd7(%rip),%xmm1
mulsd  %xmm1,%xmm2
movsd  0x1cbb(%rip),%xmm1
addsd  %xmm1,%xmm2
movsd  0x1cb7(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x370(%rax)
mov    -0x8(%rbp),%rax
movsd  0x190(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x198(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x190(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x378(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    141e <computeComputedConstants+0x2fe>
jp     141e <computeComputedConstants+0x2fe>
mov    -0x8(%rbp),%rax
movsd  0x2a0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x2b8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x2a0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    14cb <computeComputedConstants+0x3ab>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1bce(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1484 <computeComputedConstants+0x364>
jp     1484 <computeComputedConstants+0x364>
mov    -0x8(%rbp),%rax
movsd  0x290(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x2a8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x290(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    14c1 <computeComputedConstants+0x3a1>
mov    -0x8(%rbp),%rax
movsd  0x298(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x2b0(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x298(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x380(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    153d <computeComputedConstants+0x41d>
jp     153d <computeComputedConstants+0x41d>
mov    -0x8(%rbp),%rax
movsd  0x210(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x228(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x210(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    15ea <computeComputedConstants+0x4ca>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1aaf(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    15a3 <computeComputedConstants+0x483>
jp     15a3 <computeComputedConstants+0x483>
mov    -0x8(%rbp),%rax
movsd  0x200(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x218(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x200(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    15e0 <computeComputedConstants+0x4c0>
mov    -0x8(%rbp),%rax
movsd  0x208(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x220(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x208(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x388(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    165c <computeComputedConstants+0x53c>
jp     165c <computeComputedConstants+0x53c>
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x80(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    16fd <computeComputedConstants+0x5dd>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1990(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    16bc <computeComputedConstants+0x59c>
jp     16bc <computeComputedConstants+0x59c>
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x70(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    16f3 <computeComputedConstants+0x5d3>
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x78(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x390(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    176f <computeComputedConstants+0x64f>
jp     176f <computeComputedConstants+0x64f>
mov    -0x8(%rbp),%rax
movsd  0x2e0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x2f8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x2e0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    181c <computeComputedConstants+0x6fc>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x187d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    17d5 <computeComputedConstants+0x6b5>
jp     17d5 <computeComputedConstants+0x6b5>
mov    -0x8(%rbp),%rax
movsd  0x2d0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x2e8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x2d0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1812 <computeComputedConstants+0x6f2>
mov    -0x8(%rbp),%rax
movsd  0x2d8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x2f0(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x2d8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x398(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    188e <computeComputedConstants+0x76e>
jp     188e <computeComputedConstants+0x76e>
mov    -0x8(%rbp),%rax
movsd  0x350(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x368(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x350(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    193b <computeComputedConstants+0x81b>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x175e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    18f4 <computeComputedConstants+0x7d4>
jp     18f4 <computeComputedConstants+0x7d4>
mov    -0x8(%rbp),%rax
movsd  0x340(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x358(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x340(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1931 <computeComputedConstants+0x811>
mov    -0x8(%rbp),%rax
movsd  0x348(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x360(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x348(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3a8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19b0 <computeComputedConstants+0x890>
jp     19b0 <computeComputedConstants+0x890>
mov    -0x8(%rbp),%rax
movsd  0x1e0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x1f8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x1e0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1a69 <computeComputedConstants+0x949>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x163c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1a19 <computeComputedConstants+0x8f9>
jp     1a19 <computeComputedConstants+0x8f9>
mov    -0x8(%rbp),%rax
movsd  0x1d0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x1e8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x1d0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1a59 <computeComputedConstants+0x939>
mov    -0x8(%rbp),%rax
movsd  0x1d8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x1f0(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x1d8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3b8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x3b8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x160(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x15c7(%rip),%xmm1
addsd  0x160(%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3c0(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1b0(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x1b8(%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  0x1a0(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x188(%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  0x180(%rax),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3c8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1b0(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x1b8(%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  0x1a0(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x178(%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  0x170(%rax),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3d0(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1b0(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x1b8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x14bb(%rip),%xmm1
mulsd  0x1a0(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x168(%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  0x160(%rax),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3d8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1cb1 <computeComputedConstants+0xb91>
jp     1cb1 <computeComputedConstants+0xb91>
mov    -0x8(%rbp),%rax
movsd  0x1b0(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x1b8(%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  0x1a0(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x178(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x141c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x170(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x180(%rax),%xmm1
movsd  0x13f4(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1d4d <computeComputedConstants+0xc2d>
mov    -0x8(%rbp),%rax
movsd  0x1b0(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x1b8(%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  0x1a0(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x178(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x188(%rax),%xmm0
movsd  0x1373(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x170(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x180(%rax),%xmm1
movsd  0x134b(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3e0(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1dc5 <computeComputedConstants+0xca5>
jp     1dc5 <computeComputedConstants+0xca5>
mov    -0x8(%rbp),%rax
movsd  0x310(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x328(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x310(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1e7e <computeComputedConstants+0xd5e>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x1227(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1e2e <computeComputedConstants+0xd0e>
jp     1e2e <computeComputedConstants+0xd0e>
mov    -0x8(%rbp),%rax
movsd  0x300(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x318(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x300(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1e6e <computeComputedConstants+0xd4e>
mov    -0x8(%rbp),%rax
movsd  0x308(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x320(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x308(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x3e8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1eed <computeComputedConstants+0xdcd>
jp     1eed <computeComputedConstants+0xdcd>
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1f94 <computeComputedConstants+0xe74>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x10ff(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1f4d <computeComputedConstants+0xe2d>
jp     1f4d <computeComputedConstants+0xe2d>
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1f84 <computeComputedConstants+0xe64>
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x430(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2003 <computeComputedConstants+0xee3>
jp     2003 <computeComputedConstants+0xee3>
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    20aa <computeComputedConstants+0xf8a>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xfe9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2063 <computeComputedConstants+0xf43>
jp     2063 <computeComputedConstants+0xf43>
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    209a <computeComputedConstants+0xf7a>
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x480(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2122 <computeComputedConstants+0x1002>
jp     2122 <computeComputedConstants+0x1002>
mov    -0x8(%rbp),%rax
movsd  0xe0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xf8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0xe0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    21db <computeComputedConstants+0x10bb>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xeca(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    218b <computeComputedConstants+0x106b>
jp     218b <computeComputedConstants+0x106b>
mov    -0x8(%rbp),%rax
movsd  0xd0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xe8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0xd0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    21cb <computeComputedConstants+0x10ab>
mov    -0x8(%rbp),%rax
movsd  0xd8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xf0(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0xd8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x4d0(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2253 <computeComputedConstants+0x1133>
jp     2253 <computeComputedConstants+0x1133>
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xc8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0xb0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    230c <computeComputedConstants+0x11ec>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xd99(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    22bc <computeComputedConstants+0x119c>
jp     22bc <computeComputedConstants+0x119c>
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0xa0(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    22fc <computeComputedConstants+0x11dc>
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0xa8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x4d8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2384 <computeComputedConstants+0x1264>
jp     2384 <computeComputedConstants+0x1264>
mov    -0x8(%rbp),%rax
movsd  0x240(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x258(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x240(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
jmp    243d <computeComputedConstants+0x131d>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xc68(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    23ed <computeComputedConstants+0x12cd>
jp     23ed <computeComputedConstants+0x12cd>
mov    -0x8(%rbp),%rax
movsd  0x230(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x248(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x230(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    242d <computeComputedConstants+0x130d>
mov    -0x8(%rbp),%rax
movsd  0x238(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x250(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x238(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x510(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2485 <computeComputedConstants+0x1365>
jp     2485 <computeComputedConstants+0x1365>
movsd  0xc08(%rip),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    24c5 <computeComputedConstants+0x13a5>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xbe7(%rip),%xmm3
movsd  0xbe7(%rip),%xmm2
movsd  0xb57(%rip),%xmm1
cmpeqsd %xmm1,%xmm0
movaps %xmm0,%xmm1
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x540(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    253d <computeComputedConstants+0x141d>
jp     253d <computeComputedConstants+0x141d>
mov    -0x8(%rbp),%rax
movsd  0x270(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x288(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x270(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    25f6 <computeComputedConstants+0x14d6>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0xaaf(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    25a6 <computeComputedConstants+0x1486>
jp     25a6 <computeComputedConstants+0x1486>
mov    -0x8(%rbp),%rax
movsd  0x260(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x278(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x260(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
jmp    25e6 <computeComputedConstants+0x14c6>
mov    -0x8(%rbp),%rax
movsd  0x268(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x280(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x268(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x550(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    266e <computeComputedConstants+0x154e>
jp     266e <computeComputedConstants+0x154e>
mov    -0x8(%rbp),%rax
movsd  0x140(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x158(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x140(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    2727 <computeComputedConstants+0x1607>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x97e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    26d7 <computeComputedConstants+0x15b7>
jp     26d7 <computeComputedConstants+0x15b7>
mov    -0x8(%rbp),%rax
movsd  0x130(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x148(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x130(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    2717 <computeComputedConstants+0x15f7>
mov    -0x8(%rbp),%rax
movsd  0x138(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x150(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x138(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x570(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    279f <computeComputedConstants+0x167f>
jp     279f <computeComputedConstants+0x167f>
mov    -0x8(%rbp),%rax
movsd  0x110(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x128(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x110(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    2858 <computeComputedConstants+0x1738>
mov    -0x8(%rbp),%rax
movsd  0x1c0(%rax),%xmm0
movsd  0x84d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2808 <computeComputedConstants+0x16e8>
jp     2808 <computeComputedConstants+0x16e8>
mov    -0x8(%rbp),%rax
movsd  0x100(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x118(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x100(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
jmp    2848 <computeComputedConstants+0x1728>
mov    -0x8(%rbp),%rax
movsd  0x108(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x370(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x120(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x108(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x580(%rax)
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeComputedConstants>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%rbx
movsd  0x1c0(%rdi),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    119e <computeComputedConstants+0x7e>
jp     119e <computeComputedConstants+0x7e>
movsd  0x1c8(%rbx),%xmm1
movapd %xmm1,(%rsp)
movsd  0xee1(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0xedd(%rip),%xmm0
divsd  0xedd(%rip),%xmm0
call   1030 <exp@plt>
movapd (%rsp),%xmm3
unpcklpd %xmm0,%xmm3
mulpd  0xedf(%rip),%xmm3
addpd  0xee7(%rip),%xmm3
mulpd  0xeef(%rip),%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
jmp    124a <computeComputedConstants+0x12a>
ucomisd 0xe5a(%rip),%xmm0
jne    11f7 <computeComputedConstants+0xd7>
jp     11f7 <computeComputedConstants+0xd7>
movsd  0x1c8(%rbx),%xmm0
movsd  0x1a8(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
mulsd  0xe6d(%rip),%xmm0
addsd  0xe6d(%rip),%xmm0
divsd  0xe6d(%rip),%xmm0
call   1030 <exp@plt>
movapd (%rsp),%xmm3
mulsd  0xe3b(%rip),%xmm0
addsd  0xe0b(%rip),%xmm0
jmp    124a <computeComputedConstants+0x12a>
movsd  0x1c8(%rbx),%xmm0
movsd  0xe01(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
mulsd  0xdf8(%rip),%xmm0
addsd  0xdf8(%rip),%xmm0
divsd  0xdf8(%rip),%xmm0
call   1030 <exp@plt>
movapd (%rsp),%xmm3
mulsd  0xdee(%rip),%xmm0
addsd  0xdbe(%rip),%xmm0
mulsd  0xde6(%rip),%xmm0
divsd  %xmm0,%xmm3
movsd  %xmm3,0x370(%rbx)
movsd  0x190(%rbx),%xmm0
movsd  0x198(%rbx),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x378(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12d3 <computeComputedConstants+0x1b3>
jp     12d3 <computeComputedConstants+0x1b3>
mov    $0x3f,%r8d
mov    $0x3c,%eax
mov    $0x6d,%r9d
mov    $0x6a,%r10d
mov    $0x5f,%r12d
mov    $0x5c,%r14d
mov    $0x13,%r15d
mov    $0x10,%r11d
mov    $0x45,%edx
mov    $0x42,%ecx
mov    $0x57,%esi
mov    $0x54,%edi
jmp    133f <computeComputedConstants+0x21f>
cmpeqsd 0xd24(%rip),%xmm0
movq   %xmm0,%rax
and    $0x1,%eax
mov    %rax,%rdi
xor    $0x53,%rdi
mov    $0x56,%esi
sub    %rax,%rsi
mov    %rax,%rcx
xor    $0x41,%rcx
mov    $0x44,%edx
sub    %rax,%rdx
mov    %rax,%r11
xor    $0xf,%r11
mov    $0x12,%r15d
sub    %rax,%r15
mov    %rax,%r14
xor    $0x5b,%r14
mov    $0x5e,%r12d
sub    %rax,%r12
mov    %rax,%r10
xor    $0x69,%r10
mov    $0x6c,%r9d
sub    %rax,%r9
mov    $0x3e,%r8d
sub    %rax,%r8
xor    $0x3b,%rax
movsd  (%rbx,%rsi,8),%xmm0
movhpd (%rbx,%rdx,8),%xmm0
movsd  (%rbx,%rdi,8),%xmm1
movhpd (%rbx,%rcx,8),%xmm1
subpd  %xmm1,%xmm0
movapd %xmm3,%xmm2
unpcklpd %xmm3,%xmm2
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,0x380(%rbx)
movsd  (%rbx,%r15,8),%xmm0
movhpd (%rbx,%r12,8),%xmm0
movsd  (%rbx,%r11,8),%xmm1
movhpd (%rbx,%r14,8),%xmm1
subpd  %xmm1,%xmm0
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,0x390(%rbx)
movsd  (%rbx,%r10,8),%xmm0
movsd  (%rbx,%r9,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x3a8(%rbx)
movsd  (%rbx,%rax,8),%xmm0
movsd  (%rbx,%r8,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x3b8(%rbx)
movsd  0x160(%rbx),%xmm0
mulsd  %xmm0,%xmm1
addsd  0xc62(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x3c0(%rbx)
movsd  0x188(%rbx),%xmm0
movsd  0x1b0(%rbx),%xmm1
mulsd  0x1b8(%rbx),%xmm1
divsd  0x1a0(%rbx),%xmm1
movsd  %xmm1,(%rsp)
divsd  0x180(%rbx),%xmm0
call   1040 <log@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x3c8(%rbx)
movsd  0x178(%rbx),%xmm0
movsd  0x1b0(%rbx),%xmm1
mulsd  0x1b8(%rbx),%xmm1
divsd  0x1a0(%rbx),%xmm1
movsd  %xmm1,(%rsp)
divsd  0x170(%rbx),%xmm0
call   1040 <log@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x3d0(%rbx)
movsd  0x1b0(%rbx),%xmm2
mulsd  0x1b8(%rbx),%xmm2
movsd  0x168(%rbx),%xmm0
movsd  0x1a0(%rbx),%xmm1
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rsp)
divsd  0x160(%rbx),%xmm0
call   1040 <log@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x3d8(%rbx)
movsd  0x1c0(%rbx),%xmm0
ucomisd 0xb89(%rip),%xmm0
movsd  0x1b0(%rbx),%xmm0
mulsd  0x1b8(%rbx),%xmm0
divsd  0x1a0(%rbx),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x178(%rbx),%xmm1
movsd  0x188(%rbx),%xmm0
jne    151a <computeComputedConstants+0x3fa>
jp     151a <computeComputedConstants+0x3fa>
movhpd 0x180(%rbx),%xmm0
movhpd 0x170(%rbx),%xmm1
mulpd  0xb88(%rip),%xmm0
jmp    1532 <computeComputedConstants+0x412>
movhpd 0x180(%rbx),%xmm0
movhpd 0x170(%rbx),%xmm1
mulpd  0xb5e(%rip),%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movsd  (%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x3e0(%rbx)
movsd  0x1c0(%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16aa <computeComputedConstants+0x58a>
jp     16aa <computeComputedConstants+0x58a>
movsd  0x310(%rbx),%xmm1
movsd  0x370(%rbx),%xmm0
movsd  0x328(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x3e8(%rbx)
movsd  0x18(%rbx),%xmm1
movsd  0x30(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x430(%rbx)
movsd  0x50(%rbx),%xmm1
movsd  0x68(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x480(%rbx)
movsd  0xf8(%rbx),%xmm1
movhpd 0xc8(%rbx),%xmm1
movsd  0xe0(%rbx),%xmm2
movhpd 0xb0(%rbx),%xmm2
subpd  %xmm2,%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,0x4d0(%rbx)
movsd  0x240(%rbx),%xmm1
movsd  0x258(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x510(%rbx)
movabs $0x3f60624dd2f1a9fc,%rax
62 60 3f
mov    %rax,0x540(%rbx)
movsd  0x270(%rbx),%xmm1
movsd  0x288(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x550(%rbx)
movsd  0x140(%rbx),%xmm1
movsd  0x158(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x570(%rbx)
movsd  0x110(%rbx),%xmm2
movsd  0x128(%rbx),%xmm1
jmp    1925 <computeComputedConstants+0x805>
ucomisd 0x94e(%rip),%xmm0
jne    17f4 <computeComputedConstants+0x6d4>
jp     17f4 <computeComputedConstants+0x6d4>
movsd  0x300(%rbx),%xmm1
movsd  0x370(%rbx),%xmm0
movsd  0x318(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x3e8(%rbx)
movsd  0x8(%rbx),%xmm1
movsd  0x20(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x430(%rbx)
movsd  0x40(%rbx),%xmm1
movsd  0x58(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x480(%rbx)
movsd  0xe8(%rbx),%xmm1
movhpd 0xb8(%rbx),%xmm1
movsd  0xd0(%rbx),%xmm2
movhpd 0xa0(%rbx),%xmm2
subpd  %xmm2,%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,0x4d0(%rbx)
movsd  0x230(%rbx),%xmm1
movsd  0x248(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x510(%rbx)
movabs $0x3f60624dd2f1a9fc,%rax
62 60 3f
mov    %rax,0x540(%rbx)
movsd  0x260(%rbx),%xmm1
movsd  0x278(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x550(%rbx)
movsd  0x130(%rbx),%xmm1
movsd  0x148(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x570(%rbx)
movsd  0x100(%rbx),%xmm2
movsd  0x118(%rbx),%xmm1
jmp    1925 <computeComputedConstants+0x805>
movsd  0x308(%rbx),%xmm1
movsd  0x370(%rbx),%xmm0
movsd  0x320(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x3e8(%rbx)
movsd  0x10(%rbx),%xmm1
movsd  0x28(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x430(%rbx)
movsd  0x48(%rbx),%xmm1
movsd  0x60(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x480(%rbx)
movsd  0xf0(%rbx),%xmm1
movhpd 0xc0(%rbx),%xmm1
movsd  0xd8(%rbx),%xmm2
movhpd 0xa8(%rbx),%xmm2
subpd  %xmm2,%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,0x4d0(%rbx)
movsd  0x238(%rbx),%xmm1
movsd  0x250(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x510(%rbx)
movabs $0x3f789374bc6a7efa,%rax
93 78 3f
mov    %rax,0x540(%rbx)
movsd  0x268(%rbx),%xmm1
movsd  0x280(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x550(%rbx)
movsd  0x138(%rbx),%xmm1
movsd  0x150(%rbx),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x570(%rbx)
movsd  0x108(%rbx),%xmm2
movsd  0x120(%rbx),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x580(%rbx)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @computeComputedConstants(double* %0) {
%2 = getelementptr inbounds double, double* %0, i64 56
%3 = load double, double* %2
%4 = fcmp oeq double %3, 0.000000e+00
br i1 %4, label %5, label %18
5: ; preds = %1
%6 = getelementptr inbounds double, double* %0, i64 57
%7 = load double, double* %6
%8 = tail call double @llvm.fmuladd.f64(double %7, double 3.000000e+00, double -2.050000e+00)
%9 = fdiv double %8, -2.950000e-01
%10 = tail call double @exp(double %9)
%11 = insertelement <2 x double> poison, double %7, i64 0
%12 = insertelement <2 x double> %11, double %10, i64 1
%13 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %12, <2 x double> <double 3.000000e+00, double 0x3FE8C8B439581062>, <2 x double> <double -1.000000e-01, double 1.000000e+00>)
%14 = fmul <2 x double> %13, <double 1.070000e+00, double 3.000000e+00>
%15 = extractelement <2 x double> %14, i64 0
%16 = extractelement <2 x double> %14, i64 1
%17 = fdiv double %15, %16
br label %41
18: ; preds = %1
%19 = fcmp oeq double %3, 1.000000e+00
br i1 %19, label %20, label %31
20: ; preds = %18
%21 = getelementptr inbounds double, double* %0, i64 53
%22 = load double, double* %21
%23 = getelementptr inbounds double, double* %0, i64 57
%24 = load double, double* %23
%25 = fmul double %22, %24
%26 = tail call double @llvm.fmuladd.f64(double %24, double 3.000000e+00, double -2.050000e+00)
%27 = fdiv double %26, -2.950000e-01
%28 = tail call double @exp(double %27)
%29 = tail call double @llvm.fmuladd.f64(double %28, double 0x3FE8C8B439581062, double 1.000000e+00)
%30 = fdiv double %25, %29
br label %41
31: ; preds = %18
%32 = getelementptr inbounds double, double* %0, i64 57
%33 = load double, double* %32
%34 = fmul double %33, 3.103000e+01
%35 = tail call double @llvm.fmuladd.f64(double %33, double 2.900000e+01, double -2.450000e+01)
%36 = fdiv double %35, -1.950000e+00
%37 = tail call double @exp(double %36)
%38 = tail call double @llvm.fmuladd.f64(double %37, double 0x3FE8C8B439581062, double 1.000000e+00)
%39 = fmul double %38, 3.000000e+01
%40 = fdiv double %34, %39
br label %41
41: ; preds = %20, %31, %5
%42 = phi double [ %17, %5 ], [ %30, %20 ], [ %40, %31 ]
%43 = getelementptr inbounds double, double* %0, i64 110
store double %42, double* %43
%44 = getelementptr inbounds double, double* %0, i64 50
%45 = load double, double* %44
%46 = getelementptr inbounds double, double* %0, i64 51
%47 = load double, double* %46
%48 = fsub double %47, %45
%49 = tail call double @llvm.fmuladd.f64(double %42, double %48, double %45)
%50 = getelementptr inbounds double, double* %0, i64 111
store double %49, double* %50
%51 = load double, double* %2
%52 = fcmp oeq double %51, 0.000000e+00
br i1 %52, label %67, label %53
53: ; preds = %41
%54 = fcmp oeq double %51, 1.000000e+00
%55 = select i1 %54, i64 82, i64 83
%56 = select i1 %54, i64 85, i64 86
%57 = select i1 %54, i64 64, i64 65
%58 = select i1 %54, i64 67, i64 68
%59 = select i1 %54, i64 14, i64 15
%60 = select i1 %54, i64 17, i64 18
%61 = select i1 %54, i64 90, i64 91
%62 = select i1 %54, i64 93, i64 94
%63 = select i1 %54, i64 104, i64 105
%64 = select i1 %54, i64 107, i64 108
%65 = select i1 %54, i64 58, i64 59
%66 = select i1 %54, i64 61, i64 62
br label %67
67: ; preds = %41, %53
%68 = phi i64 [ %55, %53 ], [ 84, %41 ]
%69 = phi i64 [ %56, %53 ], [ 87, %41 ]
%70 = phi i64 [ %57, %53 ], [ 66, %41 ]
%71 = phi i64 [ %58, %53 ], [ 69, %41 ]
%72 = phi i64 [ %59, %53 ], [ 16, %41 ]
%73 = phi i64 [ %60, %53 ], [ 19, %41 ]
%74 = phi i64 [ %61, %53 ], [ 92, %41 ]
%75 = phi i64 [ %62, %53 ], [ 95, %41 ]
%76 = phi i64 [ %63, %53 ], [ 106, %41 ]
%77 = phi i64 [ %64, %53 ], [ 109, %41 ]
%78 = phi i64 [ %65, %53 ], [ 60, %41 ]
%79 = phi i64 [ %66, %53 ], [ 63, %41 ]
%80 = getelementptr inbounds double, double* %0, i64 %68
%81 = load double, double* %80
%82 = getelementptr inbounds double, double* %0, i64 %69
%83 = load double, double* %82
%84 = getelementptr inbounds double, double* %0, i64 112
%85 = getelementptr inbounds double, double* %0, i64 %70
%86 = load double, double* %85
%87 = getelementptr inbounds double, double* %0, i64 %71
%88 = load double, double* %87
%89 = insertelement <2 x double> poison, double %83, i64 0
%90 = insertelement <2 x double> %89, double %88, i64 1
%91 = insertelement <2 x double> poison, double %81, i64 0
%92 = insertelement <2 x double> %91, double %86, i64 1
%93 = fsub <2 x double> %90, %92
%94 = insertelement <2 x double> poison, double %42, i64 0
%95 = shufflevector <2 x double> %94, <2 x double> poison, <2 x i32> zeroinitializer
%96 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %95, <2 x double> %93, <2 x double> %92)
%97 = bitcast double* %84 to <2 x double>*
store <2 x double> %96, <2 x double>* %97
%98 = getelementptr inbounds double, double* %0, i64 %72
%99 = load double, double* %98
%100 = getelementptr inbounds double, double* %0, i64 %73
%101 = load double, double* %100
%102 = getelementptr inbounds double, double* %0, i64 114
%103 = getelementptr inbounds double, double* %0, i64 %74
%104 = load double, double* %103
%105 = getelementptr inbounds double, double* %0, i64 %75
%106 = load double, double* %105
%107 = insertelement <2 x double> poison, double %101, i64 0
%108 = insertelement <2 x double> %107, double %106, i64 1
%109 = insertelement <2 x double> poison, double %99, i64 0
%110 = insertelement <2 x double> %109, double %104, i64 1
%111 = fsub <2 x double> %108, %110
%112 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %95, <2 x double> %111, <2 x double> %110)
%113 = bitcast double* %102 to <2 x double>*
store <2 x double> %112, <2 x double>* %113
%114 = getelementptr inbounds double, double* %0, i64 %76
%115 = load double, double* %114
%116 = getelementptr inbounds double, double* %0, i64 %77
%117 = load double, double* %116
%118 = fsub double %117, %115
%119 = tail call double @llvm.fmuladd.f64(double %42, double %118, double %115)
%120 = getelementptr inbounds double, double* %0, i64 117
store double %119, double* %120
%121 = getelementptr inbounds double, double* %0, i64 %78
%122 = load double, double* %121
%123 = getelementptr inbounds double, double* %0, i64 %79
%124 = load double, double* %123
%125 = fsub double %124, %122
%126 = tail call double @llvm.fmuladd.f64(double %42, double %125, double %122)
%127 = getelementptr inbounds double, double* %0, i64 119
store double %126, double* %127
%128 = getelementptr inbounds double, double* %0, i64 44
%129 = load double, double* %128
%130 = fmul double %126, %129
%131 = fadd double %129, 4.000000e-04
%132 = fdiv double %130, %131
%133 = getelementptr inbounds double, double* %0, i64 120
store double %132, double* %133
%134 = getelementptr inbounds double, double* %0, i64 54
%135 = load double, double* %134
%136 = getelementptr inbounds double, double* %0, i64 55
%137 = load double, double* %136
%138 = fmul double %135, %137
%139 = getelementptr inbounds double, double* %0, i64 52
%140 = load double, double* %139
%141 = fdiv double %138, %140
%142 = getelementptr inbounds double, double* %0, i64 49
%143 = load double, double* %142
%144 = getelementptr inbounds double, double* %0, i64 48
%145 = load double, double* %144
%146 = fdiv double %143, %145
%147 = tail call double @log(double %146)
%148 = fmul double %141, %147
%149 = getelementptr inbounds double, double* %0, i64 121
store double %148, double* %149
%150 = load double, double* %134
%151 = load double, double* %136
%152 = fmul double %150, %151
%153 = load double, double* %139
%154 = fdiv double %152, %153
%155 = getelementptr inbounds double, double* %0, i64 47
%156 = load double, double* %155
%157 = getelementptr inbounds double, double* %0, i64 46
%158 = load double, double* %157
%159 = fdiv double %156, %158
%160 = tail call double @log(double %159)
%161 = fmul double %154, %160
%162 = getelementptr inbounds double, double* %0, i64 122
store double %161, double* %162
%163 = load double, double* %134
%164 = load double, double* %136
%165 = fmul double %163, %164
%166 = load double, double* %139
%167 = fmul double %166, 2.000000e+00
%168 = fdiv double %165, %167
%169 = getelementptr inbounds double, double* %0, i64 45
%170 = load double, double* %169
%171 = load double, double* %128
%172 = fdiv double %170, %171
%173 = tail call double @log(double %172)
%174 = fmul double %168, %173
%175 = getelementptr inbounds double, double* %0, i64 123
store double %174, double* %175
%176 = load double, double* %2
%177 = fcmp oeq double %176, 0.000000e+00
%178 = load double, double* %134
%179 = load double, double* %136
%180 = fmul double %178, %179
%181 = load double, double* %139
%182 = fdiv double %180, %181
%183 = load double, double* %155
%184 = load double, double* %142
br i1 %177, label %185, label %196
185: ; preds = %67
%186 = load double, double* %157
%187 = load double, double* %144
%188 = insertelement <2 x double> poison, double %184, i64 0
%189 = insertelement <2 x double> %188, double %187, i64 1
%190 = insertelement <2 x double> poison, double %183, i64 0
%191 = insertelement <2 x double> %190, double %186, i64 1
%192 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %189, <2 x double> <double 1.200000e-01, double 1.200000e-01>, <2 x double> %191)
%193 = extractelement <2 x double> %192, i64 0
%194 = extractelement <2 x double> %192, i64 1
%195 = fdiv double %193, %194
br label %207
196: ; preds = %67
%197 = load double, double* %157
%198 = load double, double* %144
%199 = insertelement <2 x double> poison, double %184, i64 0
%200 = insertelement <2 x double> %199, double %198, i64 1
%201 = insertelement <2 x double> poison, double %183, i64 0
%202 = insertelement <2 x double> %201, double %197, i64 1
%203 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %200, <2 x double> <double 3.000000e-02, double 3.000000e-02>, <2 x double> %202)
%204 = extractelement <2 x double> %203, i64 0
%205 = extractelement <2 x double> %203, i64 1
%206 = fdiv double %204, %205
br label %207
207: ; preds = %196, %185
%208 = phi double [ %206, %196 ], [ %195, %185 ]
%209 = tail call double @log(double %208)
%210 = fmul double %182, %209
%211 = getelementptr inbounds double, double* %0, i64 124
store double %210, double* %211
%212 = load double, double* %2
%213 = fcmp oeq double %212, 0.000000e+00
br i1 %213, label %216, label %214
214: ; preds = %207
%215 = fcmp oeq double %212, 1.000000e+00
br i1 %215, label %285, label %354
216: ; preds = %207
%217 = getelementptr inbounds double, double* %0, i64 98
%218 = load double, double* %217
%219 = load double, double* %43
%220 = getelementptr inbounds double, double* %0, i64 101
%221 = load double, double* %220
%222 = fsub double %221, %218
%223 = tail call double @llvm.fmuladd.f64(double %219, double %222, double %218)
%224 = getelementptr inbounds double, double* %0, i64 125
store double %223, double* %224
%225 = getelementptr inbounds double, double* %0, i64 3
%226 = load double, double* %225
%227 = getelementptr inbounds double, double* %0, i64 6
%228 = load double, double* %227
%229 = fsub double %228, %226
%230 = tail call double @llvm.fmuladd.f64(double %219, double %229, double %226)
%231 = getelementptr inbounds double, double* %0, i64 134
store double %230, double* %231
%232 = getelementptr inbounds double, double* %0, i64 10
%233 = load double, double* %232
%234 = getelementptr inbounds double, double* %0, i64 13
%235 = load double, double* %234
%236 = fsub double %235, %233
%237 = tail call double @llvm.fmuladd.f64(double %219, double %236, double %233)
%238 = getelementptr inbounds double, double* %0, i64 144
store double %237, double* %238
%239 = getelementptr inbounds double, double* %0, i64 28
%240 = load double, double* %239
%241 = getelementptr inbounds double, double* %0, i64 31
%242 = load double, double* %241
%243 = getelementptr inbounds double, double* %0, i64 154
%244 = getelementptr inbounds double, double* %0, i64 22
%245 = load double, double* %244
%246 = getelementptr inbounds double, double* %0, i64 25
%247 = load double, double* %246
%248 = insertelement <2 x double> poison, double %242, i64 0
%249 = insertelement <2 x double> %248, double %247, i64 1
%250 = insertelement <2 x double> poison, double %240, i64 0
%251 = insertelement <2 x double> %250, double %245, i64 1
%252 = fsub <2 x double> %249, %251
%253 = insertelement <2 x double> poison, double %219, i64 0
%254 = shufflevector <2 x double> %253, <2 x double> poison, <2 x i32> zeroinitializer
%255 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %254, <2 x double> %252, <2 x double> %251)
%256 = bitcast double* %243 to <2 x double>*
store <2 x double> %255, <2 x double>* %256
%257 = getelementptr inbounds double, double* %0, i64 72
%258 = load double, double* %257
%259 = getelementptr inbounds double, double* %0, i64 75
%260 = load double, double* %259
%261 = fsub double %260, %258
%262 = tail call double @llvm.fmuladd.f64(double %219, double %261, double %258)
%263 = getelementptr inbounds double, double* %0, i64 162
store double %262, double* %263
%264 = getelementptr inbounds double, double* %0, i64 168
store double 2.000000e-03, double* %264
%265 = getelementptr inbounds double, double* %0, i64 78
%266 = load double, double* %265
%267 = getelementptr inbounds double, double* %0, i64 81
%268 = load double, double* %267
%269 = fsub double %268, %266
%270 = tail call double @llvm.fmuladd.f64(double %219, double %269, double %266)
%271 = getelementptr inbounds double, double* %0, i64 170
store double %270, double* %271
%272 = getelementptr inbounds double, double* %0, i64 40
%273 = load double, double* %272
%274 = getelementptr inbounds double, double* %0, i64 43
%275 = load double, double* %274
%276 = fsub double %275, %273
%277 = tail call double @llvm.fmuladd.f64(double %219, double %276, double %273)
%278 = getelementptr inbounds double, double* %0, i64 174
store double %277, double* %278
%279 = getelementptr inbounds double, double* %0, i64 34
%280 = load double, double* %279
%281 = getelementptr inbounds double, double* %0, i64 37
%282 = load double, double* %281
%283 = fsub double %282, %280
%284 = tail call double @llvm.fmuladd.f64(double %219, double %283, double %280)
br label %423
285: ; preds = %214
%286 = getelementptr inbounds double, double* %0, i64 96
%287 = load double, double* %286
%288 = load double, double* %43
%289 = getelementptr inbounds double, double* %0, i64 99
%290 = load double, double* %289
%291 = fsub double %290, %287
%292 = tail call double @llvm.fmuladd.f64(double %288, double %291, double %287)
%293 = getelementptr inbounds double, double* %0, i64 125
store double %292, double* %293
%294 = getelementptr inbounds double, double* %0, i64 1
%295 = load double, double* %294
%296 = getelementptr inbounds double, double* %0, i64 4
%297 = load double, double* %296
%298 = fsub double %297, %295
%299 = tail call double @llvm.fmuladd.f64(double %288, double %298, double %295)
%300 = getelementptr inbounds double, double* %0, i64 134
store double %299, double* %300
%301 = getelementptr inbounds double, double* %0, i64 8
%302 = load double, double* %301
%303 = getelementptr inbounds double, double* %0, i64 11
%304 = load double, double* %303
%305 = fsub double %304, %302
%306 = tail call double @llvm.fmuladd.f64(double %288, double %305, double %302)
%307 = getelementptr inbounds double, double* %0, i64 144
store double %306, double* %307
%308 = getelementptr inbounds double, double* %0, i64 26
%309 = load double, double* %308
%310 = getelementptr inbounds double, double* %0, i64 29
%311 = load double, double* %310
%312 = getelementptr inbounds double, double* %0, i64 154
%313 = getelementptr inbounds double, double* %0, i64 20
%314 = load double, double* %313
%315 = getelementptr inbounds double, double* %0, i64 23
%316 = load double, double* %315
%317 = insertelement <2 x double> poison, double %311, i64 0
%318 = insertelement <2 x double> %317, double %316, i64 1
%319 = insertelement <2 x double> poison, double %309, i64 0
%320 = insertelement <2 x double> %319, double %314, i64 1
%321 = fsub <2 x double> %318, %320
%322 = insertelement <2 x double> poison, double %288, i64 0
%323 = shufflevector <2 x double> %322, <2 x double> poison, <2 x i32> zeroinitializer
%324 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %323, <2 x double> %321, <2 x double> %320)
%325 = bitcast double* %312 to <2 x double>*
store <2 x double> %324, <2 x double>* %325
%326 = getelementptr inbounds double, double* %0, i64 70
%327 = load double, double* %326
%328 = getelementptr inbounds double, double* %0, i64 73
%329 = load double, double* %328
%330 = fsub double %329, %327
%331 = tail call double @llvm.fmuladd.f64(double %288, double %330, double %327)
%332 = getelementptr inbounds double, double* %0, i64 162
store double %331, double* %332
%333 = getelementptr inbounds double, double* %0, i64 168
store double 2.000000e-03, double* %333
%334 = getelementptr inbounds double, double* %0, i64 76
%335 = load double, double* %334
%336 = getelementptr inbounds double, double* %0, i64 79
%337 = load double, double* %336
%338 = fsub double %337, %335
%339 = tail call double @llvm.fmuladd.f64(double %288, double %338, double %335)
%340 = getelementptr inbounds double, double* %0, i64 170
store double %339, double* %340
%341 = getelementptr inbounds double, double* %0, i64 38
%342 = load double, double* %341
%343 = getelementptr inbounds double, double* %0, i64 41
%344 = load double, double* %343
%345 = fsub double %344, %342
%346 = tail call double @llvm.fmuladd.f64(double %288, double %345, double %342)
%347 = getelementptr inbounds double, double* %0, i64 174
store double %346, double* %347
%348 = getelementptr inbounds double, double* %0, i64 32
%349 = load double, double* %348
%350 = getelementptr inbounds double, double* %0, i64 35
%351 = load double, double* %350
%352 = fsub double %351, %349
%353 = tail call double @llvm.fmuladd.f64(double %288, double %352, double %349)
br label %423
354: ; preds = %214
%355 = getelementptr inbounds double, double* %0, i64 97
%356 = load double, double* %355
%357 = load double, double* %43
%358 = getelementptr inbounds double, double* %0, i64 100
%359 = load double, double* %358
%360 = fsub double %359, %356
%361 = tail call double @llvm.fmuladd.f64(double %357, double %360, double %356)
%362 = getelementptr inbounds double, double* %0, i64 125
store double %361, double* %362
%363 = getelementptr inbounds double, double* %0, i64 2
%364 = load double, double* %363
%365 = getelementptr inbounds double, double* %0, i64 5
%366 = load double, double* %365
%367 = fsub double %366, %364
%368 = tail call double @llvm.fmuladd.f64(double %357, double %367, double %364)
%369 = getelementptr inbounds double, double* %0, i64 134
store double %368, double* %369
%370 = getelementptr inbounds double, double* %0, i64 9
%371 = load double, double* %370
%372 = getelementptr inbounds double, double* %0, i64 12
%373 = load double, double* %372
%374 = fsub double %373, %371
%375 = tail call double @llvm.fmuladd.f64(double %357, double %374, double %371)
%376 = getelementptr inbounds double, double* %0, i64 144
store double %375, double* %376
%377 = getelementptr inbounds double, double* %0, i64 27
%378 = load double, double* %377
%379 = getelementptr inbounds double, double* %0, i64 30
%380 = load double, double* %379
%381 = getelementptr inbounds double, double* %0, i64 154
%382 = getelementptr inbounds double, double* %0, i64 21
%383 = load double, double* %382
%384 = getelementptr inbounds double, double* %0, i64 24
%385 = load double, double* %384
%386 = insertelement <2 x double> poison, double %380, i64 0
%387 = insertelement <2 x double> %386, double %385, i64 1
%388 = insertelement <2 x double> poison, double %378, i64 0
%389 = insertelement <2 x double> %388, double %383, i64 1
%390 = fsub <2 x double> %387, %389
%391 = insertelement <2 x double> poison, double %357, i64 0
%392 = shufflevector <2 x double> %391, <2 x double> poison, <2 x i32> zeroinitializer
%393 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %392, <2 x double> %390, <2 x double> %389)
%394 = bitcast double* %381 to <2 x double>*
store <2 x double> %393, <2 x double>* %394
%395 = getelementptr inbounds double, double* %0, i64 71
%396 = load double, double* %395
%397 = getelementptr inbounds double, double* %0, i64 74
%398 = load double, double* %397
%399 = fsub double %398, %396
%400 = tail call double @llvm.fmuladd.f64(double %357, double %399, double %396)
%401 = getelementptr inbounds double, double* %0, i64 162
store double %400, double* %401
%402 = getelementptr inbounds double, double* %0, i64 168
store double 6.000000e-03, double* %402
%403 = getelementptr inbounds double, double* %0, i64 77
%404 = load double, double* %403
%405 = getelementptr inbounds double, double* %0, i64 80
%406 = load double, double* %405
%407 = fsub double %406, %404
%408 = tail call double @llvm.fmuladd.f64(double %357, double %407, double %404)
%409 = getelementptr inbounds double, double* %0, i64 170
store double %408, double* %409
%410 = getelementptr inbounds double, double* %0, i64 39
%411 = load double, double* %410
%412 = getelementptr inbounds double, double* %0, i64 42
%413 = load double, double* %412
%414 = fsub double %413, %411
%415 = tail call double @llvm.fmuladd.f64(double %357, double %414, double %411)
%416 = getelementptr inbounds double, double* %0, i64 174
store double %415, double* %416
%417 = getelementptr inbounds double, double* %0, i64 33
%418 = load double, double* %417
%419 = getelementptr inbounds double, double* %0, i64 36
%420 = load double, double* %419
%421 = fsub double %420, %418
%422 = tail call double @llvm.fmuladd.f64(double %357, double %421, double %418)
br label %423
423: ; preds = %285, %354, %216
%424 = phi double [ %284, %216 ], [ %353, %285 ], [ %422, %354 ]
%425 = getelementptr inbounds double, double* %0, i64 176
store double %424, double* %425
ret void
}