void temp_area(double sw_visible, double sw_nir, double surface_force,
               double *T, double *Tnew, double *water_density, double *de,
               int dt, double *surface, int numnod, double dz, double surfdz,
               double *temph, double *cp, double *energy_out_bottom) {
  double z[20], zhalf[20];
  double a[20], b[20], c[20];
  double d[20];
  double dist12;
  int k;
  double surface_1, surface_2, surface_avg, T1;
  double cnextra;
  double swtop;
  double top, bot;
  double water_density_new;
  double jouleold, joulenew;
  double energyinput;
  double energymixed;
  double term1, term2;
  for (k = 0; k < numnod; k++) {
    if (k == 0)
      z[k] = surfdz;
    else
      z[k] = dz;
    zhalf[k] = dz;
  }
  if (numnod > 1)
    zhalf[0] = 0.5 * (z[0] + z[1]);
  else
    zhalf[0] = 0.5 * z[0];
  energyinput = 0.0;
  energymixed = 0.0;
  surface_1 = surface[0];
  surface_2 = surface[1];
  surface_avg = (surface_1 + surface_2) / 2.;
  T1 = (sw_visible * (1 * surface_1 - surface_2 * exp(-.3 * surfdz)) +
        sw_nir * (1 * surface_1 - surface_2 * exp(-1.4 * surfdz))) /
           surface_avg +
       (surface_force * surface_1) / surface_avg;
  energyinput += T1 * surface_avg;
  cnextra = 0.5 * (surface_2 / surface_avg) * (de[0] / zhalf[0]) *
            ((T[1] - T[0]) / z[0]);
  energymixed += cnextra;
  *temph = 0.0;
  if (numnod == 1)
    Tnew[0] =
        T[0] + (T1 * dt * 3600) / ((1.e3 + water_density[0]) * cp[0] * z[0]);
  else {
    d[0] = T[0] +
           (T1 * dt * 3600) / ((1.e3 + water_density[0]) * cp[0] * z[0]) +
           cnextra * dt * 3600;
    *energy_out_bottom =
        (surface_1 - surface_2) *
        (sw_visible * exp(-.3 * surfdz) + sw_nir * exp(-1.4 * surfdz));
    for (k = 1; k < numnod - 1; k++) {
      top = (surfdz + (k - 1) * dz);
      bot = (surfdz + (k)*dz);
      surface_1 = surface[k];
      surface_2 = surface[k + 1];
      surface_avg = (surface[k] + surface[k + 1]) / 2.;
      T1 = (sw_visible *
                (surface_1 * exp(-.3 * top) - surface_2 * exp(-.3 * bot)) +
            sw_nir *
                (surface_1 * exp(-1.4 * top) - surface_2 * exp(-1.4 * bot))) /
           surface_avg;
      energyinput += T1 * surface_avg;
      term1 = 0.5 * (1. / surface_avg) *
              ((de[k] / zhalf[k]) * ((T[k + 1] - T[k]) / z[k])) * surface_2;
      term2 = 0.5 * (-1. / surface_avg) *
              ((de[k - 1] / zhalf[k - 1]) * ((T[k] - T[k - 1]) / z[k])) *
              surface_1;
      cnextra = term1 + term2;
      energymixed += (term1 + term2);
      d[k] = T[k] +
             (T1 * dt * 3600) / ((1.e3 + water_density[k]) * cp[k] * z[k]) +
             cnextra * dt * 3600;
      *energy_out_bottom +=
          (surface_1 - surface_2) *
          (sw_visible * exp(-.3 * bot) + sw_nir * exp(-1.4 * bot));
    }
    k = numnod - 1;
    surface_1 = surface[k];
    surface_2 = surface[k];
    surface_avg = surface[k];
    top = (surfdz + (k - 1) * dz);
    bot = (surfdz + (k)*dz);
    T1 =
        (sw_visible *
             (surface_1 * exp(-.3 * top) - surface_2 * exp(-.3 * bot)) +
         sw_nir * (surface_1 * exp(-1.4 * top) - surface_2 * exp(-1.4 * bot))) /
        surface_avg;
    energyinput += T1 * surface_avg;
    energyinput /= surface[0];
    cnextra = 0.5 * (-1. * surface_1 / surface_avg) *
              ((de[k - 1] / zhalf[k - 1]) * ((T[k] - T[k - 1]) / z[k]));
    *energy_out_bottom = 0.;
    *energy_out_bottom +=
        surface_2 * (sw_visible * exp(-.3 * bot) + sw_nir * exp(-1.4 * bot));
    *energy_out_bottom /= surface[0];
    energymixed += cnextra;
    d[k] = T[k] +
           (T1 * dt * 3600) / ((1.e3 + water_density[k]) * cp[k] * z[k]) +
           cnextra * dt * 3600;
    surface_2 = surface[1];
    surface_avg = (surface[0] + surface[1]) / 2.;
    b[0] = -0.5 * (de[0] / zhalf[0]) * (dt * 3600 / z[0]) * surface_2 /
           surface_avg;
    a[0] = 1. - b[0];
    for (k = 1; k < numnod - 1; k++) {
      surface_1 = surface[k];
      surface_2 = surface[k + 1];
      surface_avg = (surface[k] + surface[k + 1]) / 2.;
      b[k] = -0.5 * (de[k] / zhalf[k]) * (dt * 3600 / z[k]) * surface_2 /
             surface_avg;
      c[k] = -0.5 * (de[k - 1] / zhalf[k - 1]) * (dt * 3600 / z[k]) *
             surface_1 / surface_avg;
      a[k] = 1. - b[k] - c[k];
    }
    surface_1 = surface[numnod - 1];
    surface_avg = surface[numnod - 1];
    c[numnod - 1] = -0.5 * (de[numnod - 1] / zhalf[numnod - 1]) *
                    (dt * 3600 / z[numnod - 1]) * surface_1 / surface_avg;
    a[numnod - 1] = 1. - c[numnod - 1];
    tridia(numnod, c, a, b, d, Tnew);
  }
  energycalc(Tnew, &joulenew, numnod, dz, surfdz, surface, cp, water_density);
  *temph = 0.0;
  *temph = joulenew;
}


x86 assembly (clang, -O0):
<temp_area>:
push   %rbp
mov    %rsp,%rbp
sub    $0x5d0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8d,-0x3c(%rbp)
mov    %r9,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
movsd  %xmm4,-0x58(%rbp)
movl   $0x0,-0x42c(%rbp)
mov    -0x42c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    11f9 <temp_area+0xc9>
cmpl   $0x0,-0x42c(%rbp)
jne    11bb <temp_area+0x8b>
movsd  -0x58(%rbp),%xmm0
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
jmp    11d0 <temp_area+0xa0>
movsd  -0x50(%rbp),%xmm0
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
movsd  -0x50(%rbp),%xmm0
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
mov    -0x42c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x42c(%rbp)
jmp    1185 <temp_area+0x55>
cmpl   $0x1,0x10(%rbp)
jle    122c <temp_area+0xfc>
movsd  -0x100(%rbp),%xmm1
ff
addsd  -0xf8(%rbp),%xmm1
ff
movsd  0x1de5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
jmp    1244 <temp_area+0x114>
movsd  0x1dcc(%rip),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x490(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x498(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x438(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x440(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
addsd  -0x440(%rbp),%xmm0
ff
movsd  0x1d85(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x4b0(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
movsd  %xmm0,-0x4d8(%rbp)
ff
movsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x4e0(%rbp)
ff
movsd  0x1d3c(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1040 <exp@plt>
movsd  -0x4e0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x4d8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x4b8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x4c0(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
movsd  %xmm0,-0x4c8(%rbp)
ff
movsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x4d0(%rbp)
ff
movsd  0x1cbb(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1040 <exp@plt>
movsd  -0x4d0(%rbp),%xmm4
ff
movsd  -0x4c8(%rbp),%xmm3
ff
movsd  -0x4c0(%rbp),%xmm1
ff
movsd  -0x4b8(%rbp),%xmm2
ff
movaps %xmm0,%xmm5
movsd  -0x4b0(%rbp),%xmm0
ff
mulsd  %xmm5,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x448(%rbp),%xmm0
ff
movsd  -0x18(%rbp),%xmm1
mulsd  -0x438(%rbp),%xmm1
ff
divsd  -0x448(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x450(%rbp)
ff
movsd  -0x450(%rbp),%xmm0
ff
movsd  -0x448(%rbp),%xmm2
ff
movsd  -0x490(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x490(%rbp)
ff
movsd  -0x440(%rbp),%xmm1
ff
divsd  -0x448(%rbp),%xmm1
ff
movsd  0x1bea(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x1a0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm1
divsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x458(%rbp)
ff
movsd  -0x458(%rbp),%xmm0
ff
addsd  -0x498(%rbp),%xmm0
ff
movsd  %xmm0,-0x498(%rbp)
ff
mov    0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
cmpl   $0x1,0x10(%rbp)
jne    14da <temp_area+0x3aa>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x450(%rbp),%xmm1
ff
cvtsi2sdl -0x3c(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1b7f(%rip),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x30(%rbp),%rax
movsd  0x1b77(%rip),%xmm2
addsd  (%rax),%xmm2
mov    0x20(%rbp),%rax
mulsd  (%rax),%xmm2
mulsd  -0x100(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    22b1 <temp_area+0x1181>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x450(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x1b25(%rip),%xmm2
mulsd  %xmm2,%xmm0
mov    -0x30(%rbp),%rax
movsd  0x1b1d(%rip),%xmm2
addsd  (%rax),%xmm2
mov    0x20(%rbp),%rax
mulsd  (%rax),%xmm2
mulsd  -0x100(%rbp),%xmm2
ff
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  -0x458(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x1ae0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x420(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
subsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x4e8(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x4f8(%rbp)
ff
movsd  0x1a93(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x4f0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x500(%rbp)
ff
movsd  0x1a64(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1040 <exp@plt>
movsd  -0x500(%rbp),%xmm2
ff
movsd  -0x4f8(%rbp),%xmm1
ff
movsd  -0x4f0(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x4e8(%rbp),%xmm0
ff
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x42c(%rbp)
mov    -0x42c(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b08 <temp_area+0x9d8>
movsd  -0x58(%rbp),%xmm1
mov    -0x42c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x468(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
cvtsi2sdl -0x42c(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x470(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x438(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x42c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x440(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x42c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1966(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x528(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
movsd  %xmm0,-0x558(%rbp)
ff
movsd  0x192d(%rip),%xmm0
mulsd  -0x468(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  %xmm0,-0x560(%rbp)
ff
movsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x568(%rbp)
ff
movsd  0x1900(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  -0x568(%rbp),%xmm1
ff
movsd  -0x560(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x558(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x530(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x538(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
movsd  %xmm0,-0x548(%rbp)
ff
movsd  0x1880(%rip),%xmm0
mulsd  -0x468(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  %xmm0,-0x540(%rbp)
ff
movsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x550(%rbp)
ff
movsd  0x1853(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  -0x550(%rbp),%xmm4
ff
movsd  -0x548(%rbp),%xmm3
ff
movsd  -0x540(%rbp),%xmm5
ff
movsd  -0x538(%rbp),%xmm1
ff
movsd  -0x530(%rbp),%xmm2
ff
movaps %xmm0,%xmm6
movsd  -0x528(%rbp),%xmm0
ff
mulsd  %xmm6,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x450(%rbp)
ff
movsd  -0x450(%rbp),%xmm0
ff
movsd  -0x448(%rbp),%xmm2
ff
movsd  -0x490(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x490(%rbp)
ff
movsd  0x17cc(%rip),%xmm1
divsd  -0x448(%rbp),%xmm1
ff
movsd  0x178c(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x42c(%rbp),%rax
divsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
mov    -0x20(%rbp),%rax
mov    -0x42c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x42c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movslq -0x42c(%rbp),%rax
divsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x4a0(%rbp)
ff
movsd  0x1753(%rip),%xmm1
divsd  -0x448(%rbp),%xmm1
ff
movsd  0x1703(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x42c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x42c(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
mov    -0x20(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x42c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
movslq -0x42c(%rbp),%rax
divsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x438(%rbp),%xmm0
ff
movsd  %xmm0,-0x4a8(%rbp)
ff
movsd  -0x4a0(%rbp),%xmm0
ff
addsd  -0x4a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x458(%rbp)
ff
movsd  -0x4a0(%rbp),%xmm0
ff
addsd  -0x4a8(%rbp),%xmm0
ff
addsd  -0x498(%rbp),%xmm0
ff
movsd  %xmm0,-0x498(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x450(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x1648(%rip),%xmm2
mulsd  %xmm2,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  0x1639(%rip),%xmm2
addsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x42c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
movslq -0x42c(%rbp),%rax
mulsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  -0x458(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x15eb(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x420(%rbp,%rax,8)
ff ff
movsd  -0x438(%rbp),%xmm0
ff
subsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x508(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x518(%rbp)
ff
movsd  0x1596(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  %xmm0,-0x510(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x520(%rbp)
ff
movsd  0x1564(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  -0x520(%rbp),%xmm1
ff
movsd  -0x518(%rbp),%xmm2
ff
movsd  -0x510(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x508(%rbp),%xmm0
ff
mulsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x42c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x42c(%rbp)
jmp    15f3 <temp_area+0x4c3>
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x42c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x438(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x440(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
mov    -0x42c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x468(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
cvtsi2sdl -0x42c(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x470(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x590(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
movsd  %xmm0,-0x5c0(%rbp)
ff
movsd  0x1446(%rip),%xmm0
mulsd  -0x468(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  %xmm0,-0x5c8(%rbp)
ff
movsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x5d0(%rbp)
ff
movsd  0x1419(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  -0x5d0(%rbp),%xmm1
ff
movsd  -0x5c8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x5c0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x598(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x5a0(%rbp)
ff
movsd  -0x438(%rbp),%xmm0
ff
movsd  %xmm0,-0x5b0(%rbp)
ff
movsd  0x1399(%rip),%xmm0
mulsd  -0x468(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  %xmm0,-0x5a8(%rbp)
ff
movsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x5b8(%rbp)
ff
movsd  0x136c(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  -0x5b8(%rbp),%xmm4
ff
movsd  -0x5b0(%rbp),%xmm3
ff
movsd  -0x5a8(%rbp),%xmm5
ff
movsd  -0x5a0(%rbp),%xmm1
ff
movsd  -0x598(%rbp),%xmm2
ff
movaps %xmm0,%xmm6
movsd  -0x590(%rbp),%xmm0
ff
mulsd  %xmm6,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x450(%rbp)
ff
movsd  -0x450(%rbp),%xmm0
ff
movsd  -0x448(%rbp),%xmm2
ff
movsd  -0x490(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x490(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x490(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x490(%rbp)
ff
movsd  0x12d9(%rip),%xmm1
mulsd  -0x438(%rbp),%xmm1
ff
divsd  -0x448(%rbp),%xmm1
ff
movsd  0x1281(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x42c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x42c(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
mov    -0x20(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x42c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
movslq -0x42c(%rbp),%rax
divsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x458(%rbp)
ff
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x440(%rbp),%xmm0
ff
movsd  %xmm0,-0x570(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x580(%rbp)
ff
movsd  0x11ef(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  %xmm0,-0x578(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x588(%rbp)
ff
movsd  0x11bd(%rip),%xmm0
mulsd  -0x470(%rbp),%xmm0
ff
call   1040 <exp@plt>
movsd  -0x588(%rbp),%xmm1
ff
movsd  -0x580(%rbp),%xmm2
ff
movsd  -0x578(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x570(%rbp),%xmm0
ff
mulsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x458(%rbp),%xmm0
ff
addsd  -0x498(%rbp),%xmm0
ff
movsd  %xmm0,-0x498(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x450(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x112c(%rip),%xmm2
mulsd  %xmm2,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  0x111d(%rip),%xmm2
addsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x42c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
movslq -0x42c(%rbp),%rax
mulsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  -0x458(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x10cf(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x420(%rbp,%rax,8)
ff ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x440(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  0x1085(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x1a0(%rbp),%xmm1
ff
movsd  0x1081(%rip),%xmm0
mulsd  %xmm1,%xmm0
imul   $0xe10,-0x3c(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mulsd  -0x440(%rbp),%xmm0
ff
divsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x2e0(%rbp)
ff
movsd  0x103e(%rip),%xmm0
subsd  -0x2e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
movl   $0x1,-0x42c(%rbp)
mov    -0x42c(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    21b9 <temp_area+0x1089>
mov    -0x48(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x438(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x42c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x440(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x42c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xf96(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x42c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x42c(%rbp),%rax
divsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
movsd  0xf82(%rip),%xmm0
mulsd  %xmm1,%xmm0
imul   $0xe10,-0x3c(%rbp),%eax
cvtsi2sd %eax,%xmm1
movslq -0x42c(%rbp),%rax
divsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm1,%xmm0
mulsd  -0x440(%rbp),%xmm0
ff
divsd  -0x448(%rbp),%xmm0
ff
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x2e0(%rbp,%rax,8)
ff ff
mov    -0x38(%rbp),%rax
mov    -0x42c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x42c(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
movsd  0xf0e(%rip),%xmm0
mulsd  %xmm1,%xmm0
imul   $0xe10,-0x3c(%rbp),%eax
cvtsi2sd %eax,%xmm1
movslq -0x42c(%rbp),%rax
divsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm1,%xmm0
mulsd  -0x438(%rbp),%xmm0
ff
divsd  -0x448(%rbp),%xmm0
ff
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x380(%rbp,%rax,8)
ff ff
movslq -0x42c(%rbp),%rax
movsd  0xeb4(%rip),%xmm0
subsd  -0x2e0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x42c(%rbp),%rax
subsd  -0x380(%rbp,%rax,8),%xmm0
ff ff
movslq -0x42c(%rbp),%rax
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
mov    -0x42c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x42c(%rbp)
jmp    200c <temp_area+0xedc>
mov    -0x48(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x438(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
movsd  0xe20(%rip),%xmm0
mulsd  %xmm1,%xmm0
imul   $0xe10,-0x3c(%rbp),%eax
cvtsi2sd %eax,%xmm1
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm1,%xmm0
mulsd  -0x438(%rbp),%xmm0
ff
divsd  -0x448(%rbp),%xmm0
ff
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  %xmm0,-0x380(%rbp,%rax,8)
ff ff
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  0xdc3(%rip),%xmm0
subsd  -0x380(%rbp,%rax,8),%xmm0
ff ff
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
mov    0x10(%rbp),%edi
lea    -0x380(%rbp),%rsi
lea    -0x240(%rbp),%rdx
lea    -0x2e0(%rbp),%rcx
lea    -0x420(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    $0x0,%al
call   1050 <tridia@plt>
mov    -0x28(%rbp),%rdi
mov    0x10(%rbp),%edx
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0x48(%rbp),%rcx
mov    0x20(%rbp),%r8
mov    -0x30(%rbp),%r9
lea    -0x488(%rbp),%rsi
mov    $0x2,%al
call   1030 <energycalc@plt>
mov    0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x488(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x5d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<temp_area>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x488,%rsp
mov    %r9,%r12
mov    %r8d,0x2c(%rsp)
mov    %rcx,0xb0(%rsp)
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
movsd  %xmm2,0x8(%rsp)
movsd  %xmm1,0x50(%rsp)
movsd  %xmm0,0x58(%rsp)
mov    0x4c0(%rsp),%ebp
movapd %xmm4,%xmm1
test   %ebp,%ebp
jle    131a <temp_area+0x1ea>
cmp    $0x1,%ebp
jne    1196 <temp_area+0x66>
movsd  %xmm4,0xc0(%rsp)
movapd %xmm4,%xmm1
jmp    131a <temp_area+0x1ea>
mov    %ebp,%eax
lea    -0x1(%rax),%r9
mov    $0x1,%ecx
cmp    $0x4,%r9
jb     12e0 <temp_area+0x1b0>
mov    %rbp,%r8
mov    %r9,%rcx
and    $0xfffffffffffffffc,%rcx
movaps %xmm3,%xmm0
movlhps %xmm3,%xmm0
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0xc,%rdi
jae    11dc <temp_area+0xac>
xor    %edi,%edi
jmp    127e <temp_area+0x14e>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups %xmm0,0xc8(%rsp,%rdi,8)
movups %xmm0,0xd8(%rsp,%rdi,8)
movups %xmm0,0x168(%rsp,%rdi,8)
movups %xmm0,0x178(%rsp,%rdi,8)
movups %xmm0,0xe8(%rsp,%rdi,8)
movups %xmm0,0xf8(%rsp,%rdi,8)
movups %xmm0,0x188(%rsp,%rdi,8)
movups %xmm0,0x198(%rsp,%rdi,8)
movups %xmm0,0x108(%rsp,%rdi,8)
movups %xmm0,0x118(%rsp,%rdi,8)
movups %xmm0,0x1a8(%rsp,%rdi,8)
movups %xmm0,0x1b8(%rsp,%rdi,8)
movups %xmm0,0x128(%rsp,%rdi,8)
movups %xmm0,0x138(%rsp,%rdi,8)
movups %xmm0,0x1c8(%rsp,%rdi,8)
movups %xmm0,0x1d8(%rsp,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    11f0 <temp_area+0xc0>
test   %rbp,%rbp
je     12c6 <temp_area+0x196>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rdi,8),%rsi
or     $0x8,%rsi
movups %xmm0,0xc0(%rsp,%rsi,1)
movups %xmm0,0xd0(%rsp,%rsi,1)
movups %xmm0,0x160(%rsp,%rsi,1)
movups %xmm0,0x170(%rsp,%rsi,1)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rbp
jne    1290 <temp_area+0x160>
cmp    %rcx,%r9
mov    %r8,%rbp
je     12fb <temp_area+0x1cb>
or     $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm3,0xc0(%rsp,%rcx,8)
movsd  %xmm3,0x160(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12e0 <temp_area+0x1b0>
movsd  %xmm4,0xc0(%rsp)
movapd %xmm4,%xmm1
cmp    $0x2,%ebp
jl     131a <temp_area+0x1ea>
movsd  0xc8(%rsp),%xmm1
addsd  %xmm4,%xmm1
movaps %xmm3,0x80(%rsp)
movsd  0xcd6(%rip),%xmm0
mulsd  %xmm0,%xmm1
movapd %xmm1,0x70(%rsp)
movsd  %xmm1,0x160(%rsp)
movsd  (%r12),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x8(%r12),%xmm2
movsd  %xmm2,0x10(%rsp)
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0xc9d(%rip),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  %xmm4,0x20(%rsp)
call   1040 <exp@plt>
mulsd  0x10(%rsp),%xmm0
movsd  (%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0xc73(%rip),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
call   1040 <exp@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x10(%rsp),%xmm7
mulsd  %xmm7,%xmm0
movsd  (%rsp),%xmm2
movapd %xmm2,%xmm1
subsd  %xmm0,%xmm1
movsd  0x50(%rsp),%xmm4
mulsd  %xmm4,%xmm1
movsd  0x58(%rsp),%xmm3
movsd  0x18(%rsp),%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
divsd  %xmm5,%xmm0
movapd %xmm0,%xmm1
movsd  0x8(%rsp),%xmm6
movapd %xmm2,%xmm0
movapd %xmm2,%xmm8
mulsd  %xmm2,%xmm6
divsd  %xmm5,%xmm6
addsd  %xmm1,%xmm6
mov    0xb0(%rsp),%r13
movsd  0x0(%r13),%xmm1
movsd  (%r15),%xmm2
movsd  0x8(%r15),%xmm0
mov    0x4c8(%rsp),%rax
movq   $0x0,(%rax)
cmp    $0x1,%ebp
jne    148f <temp_area+0x35f>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x2c(%rsp),%xmm0
mulsd  %xmm0,%xmm6
mulsd  0xbca(%rip),%xmm6
mov    %rbx,%r9
movsd  (%rbx),%xmm0
addsd  0xbc3(%rip),%xmm0
mov    0x4d0(%rsp),%r8
mulsd  (%r8),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  %xmm1,%xmm0
divsd  %xmm0,%xmm6
addsd  (%r15),%xmm6
movsd  %xmm6,(%r14)
mov    0x4c8(%rsp),%rbx
jmp    1d7d <temp_area+0xc4d>
mov    %r14,0xa8(%rsp)
mov    0x4d8(%rsp),%r14
movapd %xmm7,%xmm3
divsd  %xmm5,%xmm3
mulsd  0xb51(%rip),%xmm3
divsd  0x70(%rsp),%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm2,%xmm0
movsd  0x20(%rsp),%xmm2
divsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
xorps  %xmm3,%xmm3
cvtsi2sdl 0x2c(%rsp),%xmm3
mulsd  %xmm3,%xmm6
movsd  0xb38(%rip),%xmm5
mov    %rbx,0x60(%rsp)
movsd  (%rbx),%xmm1
addsd  0xb2f(%rip),%xmm1
mulsd  %xmm5,%xmm6
mov    0x4d0(%rsp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm6
addsd  (%r15),%xmm6
movsd  %xmm3,0x68(%rsp)
mulsd  %xmm3,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm0,0x2a0(%rsp)
subsd  %xmm7,%xmm8
movsd  %xmm8,(%rsp)
movsd  0x48(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <exp@plt>
mulsd  0x50(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x58(%rsp),%xmm1
addsd  %xmm0,%xmm1
mulsd  (%rsp),%xmm1
lea    -0x1(%rbp),%eax
mov    %eax,0x28(%rsp)
movsd  %xmm1,(%r14)
cmp    $0x3,%ebp
movapd 0x80(%rsp),%xmm1
jl     1819 <temp_area+0x6e9>
mov    0x28(%rsp),%ebp
add    $0xffffffffffffffff,%rbp
xor    %ebx,%ebx
movapd 0x70(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
nop
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
mulsd  %xmm1,%xmm2
lea    0x1(%rbx),%r14
xorps  %xmm3,%xmm3
cvtsi2sd %r14d,%xmm3
movsd  0x20(%rsp),%xmm0
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm4
movsd  %xmm2,0x38(%rsp)
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%rsp)
movsd  0x8(%r12,%rbx,8),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x10(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x30(%rsp)
movapd %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  0x9fe(%rip),%xmm0
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x40(%rsp)
movapd %xmm4,%xmm0
movsd  0x9f0(%rip),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
mulsd  0x9d4(%rip),%xmm0
movsd  %xmm0,0x48(%rsp)
call   1040 <exp@plt>
mulsd  0x30(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x9ad(%rip),%xmm1
movsd  0x38(%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x38(%rsp)
movsd  (%rsp),%xmm0
mulsd  0x98b(%rip),%xmm0
movsd  %xmm0,(%rsp)
call   1040 <exp@plt>
movsd  0x30(%rsp),%xmm9
mulsd  %xmm9,%xmm0
movsd  0x10(%rsp),%xmm8
movsd  0x38(%rsp),%xmm1
mulsd  %xmm8,%xmm1
subsd  %xmm0,%xmm1
mulsd  0x50(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  0x58(%rsp),%xmm2
addsd  %xmm1,%xmm2
movsd  0x40(%rsp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x94f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x0(%r13,%rbx,8),%xmm10
movsd  0x8(%r13,%rbx,8),%xmm1
divsd  0x18(%rsp),%xmm10
movsd  0x8(%r15,%rbx,8),%xmm3
movsd  0xc8(%rsp,%rbx,8),%xmm4
mov    0x60(%rsp),%rax
movsd  0x8(%rax,%rbx,8),%xmm5
movsd  0x68(%rsp),%xmm6
mulsd  %xmm6,%xmm2
addsd  0x901(%rip),%xmm5
mov    0x4d0(%rsp),%rax
mulsd  0x8(%rax,%rbx,8),%xmm5
movsd  0x8e3(%rip),%xmm7
mulsd  %xmm7,%xmm2
mulsd  %xmm4,%xmm5
divsd  %xmm5,%xmm2
movsd  0x10(%r15,%rbx,8),%xmm5
subsd  %xmm3,%xmm5
addsd  %xmm3,%xmm2
subsd  (%r15,%rbx,8),%xmm3
divsd  %xmm4,%xmm5
divsd  %xmm4,%xmm3
movsd  0x168(%rsp,%rbx,8),%xmm4
movsd  %xmm4,0x18(%rsp)
divsd  %xmm4,%xmm1
mulsd  %xmm1,%xmm5
mulsd  %xmm10,%xmm3
mulsd  0x87e(%rip),%xmm0
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm3
mulsd  %xmm9,%xmm5
movapd %xmm8,%xmm0
mulsd  %xmm8,%xmm3
subsd  %xmm3,%xmm5
mulsd  %xmm6,%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm2,%xmm5
subsd  %xmm9,%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  %xmm5,0x2a8(%rsp,%rbx,8)
movsd  0x48(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
call   1040 <exp@plt>
movapd 0x80(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm0
movsd  0x8(%rsp),%xmm2
mulsd  0x58(%rsp),%xmm2
addsd  %xmm0,%xmm2
mulsd  0x10(%rsp),%xmm2
mov    0x4d8(%rsp),%rax
addsd  (%rax),%xmm2
movsd  %xmm2,(%rax)
mov    %r14,%rbx
cmp    %r14,%rbp
jne    15a0 <temp_area+0x470>
mov    0x28(%rsp),%ecx
movslq %ecx,%r14
movsd  (%r12,%r14,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x4c0(%rsp),%ebx
lea    -0x2(%rbx),%eax
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
mulsd  %xmm1,%xmm2
movsd  0x20(%rsp),%xmm0
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsp)
xorps  %xmm3,%xmm3
cvtsi2sd %ecx,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%rsp)
movapd %xmm2,%xmm0
mulsd  0x797(%rip),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x784(%rip),%xmm0
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
call   1040 <exp@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0x768(%rip),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x38(%rsp)
movsd  (%rsp),%xmm0
mulsd  0x750(%rip),%xmm0
movsd  %xmm0,(%rsp)
call   1040 <exp@plt>
movsd  %xmm0,0xa0(%rsp)
movslq %ebx,%rax
movsd  -0x10(%r13,%rax,8),%xmm0
divsd  0x150(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r15,%r14,8),%xmm0
subsd  -0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0xc0(%rsp,%r14,8),%xmm0
movsd  %xmm0,0x98(%rsp)
mov    0x4d8(%rsp),%rbp
movq   $0x0,0x0(%rbp)
movsd  0x18(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x18(%rsp)
movsd  (%rsp),%xmm0
call   1040 <exp@plt>
movsd  0x98(%rsp),%xmm15
imul   $0xe10,0x2c(%rsp),%eax
movsd  0x10(%rsp),%xmm5
movsd  0x40(%rsp),%xmm1
mulsd  %xmm5,%xmm1
movsd  0x30(%rsp),%xmm4
mulsd  %xmm5,%xmm4
subsd  %xmm1,%xmm4
movsd  0xa0(%rsp),%xmm2
mulsd  %xmm5,%xmm2
movsd  0x38(%rsp),%xmm1
mulsd  %xmm5,%xmm1
subsd  %xmm2,%xmm1
movsd  0x50(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm1,%xmm2
movsd  0x58(%rsp),%xmm1
mulsd  %xmm1,%xmm4
addsd  %xmm2,%xmm4
divsd  %xmm5,%xmm4
movapd %xmm5,%xmm2
divsd  %xmm5,%xmm2
movsd  0x677(%rip),%xmm10
mulsd  %xmm10,%xmm2
movsd  0x48(%rsp),%xmm6
divsd  %xmm15,%xmm6
mulsd  %xmm3,%xmm0
movsd  0x18(%rsp),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm3
addsd  0x0(%rbp),%xmm3
mulsd  0x8(%rsp),%xmm6
movapd %xmm6,%xmm5
movsd  %xmm3,0x0(%rbp)
divsd  (%r12),%xmm3
movsd  %xmm3,0x0(%rbp)
movsd  0x68(%rsp),%xmm1
mulsd  %xmm1,%xmm4
movsd  0x608(%rip),%xmm3
mulsd  %xmm3,%xmm4
mov    0x60(%rsp),%rcx
movsd  (%rcx,%r14,8),%xmm0
addsd  0x5f9(%rip),%xmm0
mov    0x4d0(%rsp),%rcx
mulsd  (%rcx,%r14,8),%xmm0
mulsd  %xmm15,%xmm0
divsd  %xmm0,%xmm4
addsd  (%r15,%r14,8),%xmm4
movapd %xmm6,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,0x2a0(%rsp,%r14,8)
movsd  0x8(%r12),%xmm1
movsd  (%r12),%xmm2
addsd  %xmm1,%xmm2
mulsd  0x585(%rip),%xmm2
movsd  0x0(%r13),%xmm4
movapd %xmm4,%xmm3
movapd 0x70(%rsp),%xmm7
divsd  %xmm7,%xmm3
mulsd  %xmm10,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm5
divsd  0x20(%rsp),%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm1,%xmm5
divsd  %xmm2,%xmm5
movsd  %xmm5,0x3e0(%rsp)
movsd  0x565(%rip),%xmm11
movapd %xmm11,%xmm3
subsd  %xmm5,%xmm3
movsd  %xmm3,0x200(%rsp)
cmp    $0x3,%ebx
movsd  0x51f(%rip),%xmm13
jl     1cde <temp_area+0xbae>
mov    0x28(%rsp),%r9d
lea    -0x1(%r9),%rdx
mov    $0x1,%r8d
cmp    $0x2,%rdx
jb     1c15 <temp_area+0xae5>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %rdx,%r8
or     $0x1,%r8
unpcklpd %xmm7,%xmm7
unpcklpd %xmm4,%xmm4
unpcklpd %xmm1,%xmm1
movapd %xmm0,%xmm14
unpcklpd %xmm0,%xmm14
xor    %edi,%edi
movapd 0x511(%rip),%xmm8
movapd 0x518(%rip),%xmm12
movapd 0x51f(%rip),%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm3
movapd %xmm4,%xmm6
movapd %xmm7,%xmm2
movupd 0x10(%r12,%rdi,8),%xmm1
shufpd $0x1,%xmm1,%xmm3
movupd 0x8(%r13,%rdi,8),%xmm4
shufpd $0x1,%xmm4,%xmm6
movupd 0x168(%rsp,%rdi,8),%xmm7
shufpd $0x1,%xmm7,%xmm2
divpd  %xmm2,%xmm6
movupd 0xc8(%rsp,%rdi,8),%xmm2
movapd %xmm14,%xmm5
divpd  %xmm2,%xmm5
mulpd  %xmm12,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm1,%xmm3
mulpd  %xmm8,%xmm3
movapd %xmm4,%xmm2
divpd  %xmm7,%xmm2
mulpd  %xmm12,%xmm2
mulpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm2
divpd  %xmm3,%xmm2
movupd %xmm2,0x3e8(%rsp,%rdi,8)
divpd  %xmm3,%xmm6
movupd %xmm6,0x348(%rsp,%rdi,8)
movapd %xmm9,%xmm3
subpd  %xmm2,%xmm3
subpd  %xmm6,%xmm3
movupd %xmm3,0x208(%rsp,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    1b50 <temp_area+0xa20>
cmp    %rsi,%rdx
je     1cde <temp_area+0xbae>
unpckhpd %xmm7,%xmm7
unpckhpd %xmm4,%xmm4
unpckhpd %xmm1,%xmm1
lea    (%rsp,%r8,8),%r10
add    $0x200,%r10
lea    0x340(%rsp,%r8,8),%rsi
lea    0x3e0(%rsp,%r8,8),%rdi
lea    (%rsp,%r8,8),%rbp
add    $0xc0,%rbp
lea    (%rsp,%r8,8),%rcx
add    $0x160,%rcx
lea    0x0(,%r8,8),%rbx
add    %r13,%rbx
sub    %r8,%r9
lea    (%r12,%r8,8),%rax
add    $0x8,%rax
xor    %edx,%edx
xchg   %ax,%ax
divsd  %xmm7,%xmm4
movapd %xmm0,%xmm2
divsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  %xmm10,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm4
movsd  (%rax,%rdx,8),%xmm3
addsd  %xmm3,%xmm1
mulsd  %xmm13,%xmm1
movsd  (%rbx,%rdx,8),%xmm5
movsd  (%rcx,%rdx,8),%xmm7
movapd %xmm5,%xmm6
divsd  %xmm7,%xmm6
mulsd  %xmm10,%xmm6
mulsd  %xmm2,%xmm6
mulsd  %xmm3,%xmm6
divsd  %xmm1,%xmm6
movsd  %xmm6,(%rdi,%rdx,8)
divsd  %xmm1,%xmm4
movsd  %xmm4,(%rsi,%rdx,8)
movapd %xmm11,%xmm1
subsd  %xmm6,%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%r10,%rdx,8)
add    $0x1,%rdx
movapd %xmm5,%xmm4
movapd %xmm3,%xmm1
cmp    %rdx,%r9
jne    1c60 <temp_area+0xb30>
movsd  0x0(%r13,%r14,8),%xmm1
divsd  0x160(%rsp,%r14,8),%xmm1
mulsd  0x339(%rip),%xmm1
movsd  (%r12,%r14,8),%xmm2
divsd  %xmm15,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x340(%rsp,%r14,8)
subsd  %xmm0,%xmm11
movsd  %xmm11,0x200(%rsp,%r14,8)
lea    0x340(%rsp),%rsi
lea    0x200(%rsp),%rdx
lea    0x3e0(%rsp),%rcx
lea    0x2a0(%rsp),%r8
mov    0x4c0(%rsp),%ebp
mov    %ebp,%edi
mov    0xa8(%rsp),%r14
mov    %r14,%r9
xor    %eax,%eax
call   1050 <tridia@plt>
movsd  0x20(%rsp),%xmm1
mov    0x60(%rsp),%r9
mov    0x4c8(%rsp),%rbx
mov    0x4d0(%rsp),%r8
lea    0xb8(%rsp),%rsi
mov    %r14,%rdi
mov    %ebp,%edx
movaps 0x80(%rsp),%xmm0
mov    %r12,%rcx
mov    $0x2,%al
call   1030 <energycalc@plt>
movsd  0xb8(%rsp),%xmm0
movsd  %xmm0,(%rbx)
add    $0x488,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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