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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double);
int fabs(double const);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ get_derivative_nac(double *, double *, int const,
                                      double const *, double const *,
                                      double const *, double const *,
                                      double const *, double const *, double);
scalar_t__ malloc(int);
double sin(double);
double sqrt(double const);
void get_derivative_dynmat_at_q(double *derivative_dynmat, const int num_patom,
                                const int num_satom, const double *fc,
                                const double *q, const double *lattice,
                                const double *r, const int *multi,
                                const double *mass, const int *s2p_map,
                                const int *p2s_map, const double nac_factor,
                                const double *born, const double *dielectric,
                                const double *q_direction) {
  int i, j, k, l, m, n, adrs, adrsT, is_nac;
  double coef[3], real_coef[3], imag_coef[3];
  double c, s, phase, mass_sqrt, fc_elem, factor, real_phase, imag_phase;
  double ddm_real[3][3][3], ddm_imag[3][3][3];
  double *ddnac, *dnac;
  if (born) {
    is_nac = 1;
    if (q_direction) {
      if (fabs(q_direction[0]) < 1e-5 && fabs(q_direction[1]) < 1e-5 &&
          fabs(q_direction[2]) < 1e-5) {
        is_nac = 0;
      }
    } else {
      if (fabs(q[0]) < 1e-5 && fabs(q[1]) < 1e-5 && fabs(q[2]) < 1e-5) {
        is_nac = 0;
      }
    }
  } else {
    is_nac = 0;
  }
  if (is_nac) {
    ddnac = (double *)malloc(sizeof(double) * num_patom * num_patom * 27);
    dnac = (double *)malloc(sizeof(double) * num_patom * num_patom * 9);
    factor = nac_factor * num_patom / num_satom;
    get_derivative_nac(ddnac, dnac, num_patom, lattice, mass, q, born,
                       dielectric, q_direction, factor);
  }
  for (i = 0; i < num_patom; i++) {
    for (j = 0; j < num_patom; j++) {
      mass_sqrt = sqrt(mass[i] * mass[j]);
      for (k = 0; k < 3; k++) {
        for (l = 0; l < 3; l++) {
          for (m = 0; m < 3; m++) {
            ddm_real[m][k][l] = 0;
            ddm_imag[m][k][l] = 0;
          }
        }
      }
      for (k = 0; k < num_satom; k++) {
        if (s2p_map[k] != p2s_map[j]) {
          continue;
        }
        real_phase = 0;
        imag_phase = 0;
        for (l = 0; l < 3; l++) {
          real_coef[l] = 0;
          imag_coef[l] = 0;
        }
        for (l = 0; l < multi[k * num_patom + i]; l++) {
          phase = 0;
          for (m = 0; m < 3; m++) {
            phase += q[m] * r[k * num_patom * 81 + i * 81 + l * 3 + m];
          }
          s = sin(phase * 2 * 3.14159265358979323846);
          c = cos(phase * 2 * 3.14159265358979323846);
          real_phase += c;
          imag_phase += s;
          for (m = 0; m < 3; m++) {
            coef[m] = 0;
            for (n = 0; n < 3; n++) {
              coef[m] += 2 * 3.14159265358979323846 * lattice[m * 3 + n] *
                         r[k * num_patom * 81 + i * 81 + l * 3 + n];
            }
          }
          for (m = 0; m < 3; m++) {
            real_coef[m] -= coef[m] * s;
            imag_coef[m] += coef[m] * c;
          }
        }
        real_phase /= multi[k * num_patom + i];
        imag_phase /= multi[k * num_patom + i];
        for (l = 0; l < 3; l++) {
          real_coef[l] /= multi[k * num_patom + i];
          imag_coef[l] /= multi[k * num_patom + i];
        }
        for (l = 0; l < 3; l++) {
          for (m = 0; m < 3; m++) {
            fc_elem =
                fc[p2s_map[i] * num_satom * 9 + k * 9 + l * 3 + m] / mass_sqrt;
            if (is_nac) {
              fc_elem += dnac[i * 9 * num_patom + j * 9 + l * 3 + m];
            }
            for (n = 0; n < 3; n++) {
              ddm_real[n][l][m] += fc_elem * real_coef[n];
              ddm_imag[n][l][m] += fc_elem * imag_coef[n];
              if (is_nac) {
                ddm_real[n][l][m] +=
                    ddnac[n * num_patom * num_patom * 9 + i * 9 * num_patom +
                          j * 9 + l * 3 + m] *
                    real_phase;
                ddm_imag[n][l][m] +=
                    ddnac[n * num_patom * num_patom * 9 + i * 9 * num_patom +
                          j * 9 + l * 3 + m] *
                    imag_phase;
              }
            }
          }
        }
      }
      for (k = 0; k < 3; k++) {
        for (l = 0; l < 3; l++) {
          for (m = 0; m < 3; m++) {
            adrs = (k * num_patom * num_patom * 18 +
                    (i * 3 + l) * num_patom * 6 + j * 6 + m * 2);
            derivative_dynmat[adrs] += ddm_real[k][l][m];
            derivative_dynmat[adrs + 1] += ddm_imag[k][l][m];
          }
        }
      }
    }
  }
  for (i = 0; i < 3; i++) {
    for (j = i; j < num_patom * 3; j++) {
      for (k = 0; k < num_patom * 3; k++) {
        adrs = i * num_patom * num_patom * 18 + j * num_patom * 6 + k * 2;
        adrsT = i * num_patom * num_patom * 18 + k * num_patom * 6 + j * 2;
        derivative_dynmat[adrs] += derivative_dynmat[adrsT];
        derivative_dynmat[adrs] /= 2;
        derivative_dynmat[adrs + 1] -= derivative_dynmat[adrsT + 1];
        derivative_dynmat[adrs + 1] /= 2;
        derivative_dynmat[adrsT] = derivative_dynmat[adrs];
        derivative_dynmat[adrsT + 1] = -derivative_dynmat[adrs + 1];
      }
    }
  }
  if (is_nac) {
    free(ddnac);
    free(dnac);
  }
}


x86 assembly (clang, -O0):
<get_derivative_dynmat_at_q>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2e0,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
cmpq   $0x0,0x38(%rbp)
je     12c6 <get_derivative_dynmat_at_q+0x156>
movl   $0x1,-0x54(%rbp)
cmpq   $0x0,0x48(%rbp)
je     124a <get_derivative_dynmat_at_q+0xda>
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xe14(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1245 <get_derivative_dynmat_at_q+0xd5>
mov    0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xdf0(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1245 <get_derivative_dynmat_at_q+0xd5>
mov    0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xdcc(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1245 <get_derivative_dynmat_at_q+0xd5>
movl   $0x0,-0x54(%rbp)
jmp    12c1 <get_derivative_dynmat_at_q+0x151>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd9d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    12bc <get_derivative_dynmat_at_q+0x14c>
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd79(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    12bc <get_derivative_dynmat_at_q+0x14c>
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd55(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    12bc <get_derivative_dynmat_at_q+0x14c>
movl   $0x0,-0x54(%rbp)
jmp    12c1 <get_derivative_dynmat_at_q+0x151>
jmp    12cd <get_derivative_dynmat_at_q+0x15d>
movl   $0x0,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
je     137e <get_derivative_dynmat_at_q+0x20e>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
imul   $0x1b,%rax,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x2b8(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
imul   $0x9,%rax,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x2c0(%rbp)
movsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x2b8(%rbp),%rdi
mov    -0x2c0(%rbp),%rsi
mov    -0xc(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x20(%rbp),%r8
mov    -0x20(%rbp),%r9
mov    0x38(%rbp),%r11
mov    0x40(%rbp),%r10
mov    0x48(%rbp),%rax
movsd  -0xe0(%rbp),%xmm0
ff
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1050 <get_derivative_nac@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bf4 <get_derivative_dynmat_at_q+0xa84>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1be1 <get_derivative_dynmat_at_q+0xa71>
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    1484 <get_derivative_dynmat_at_q+0x314>
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    1471 <get_derivative_dynmat_at_q+0x301>
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    145e <get_derivative_dynmat_at_q+0x2ee>
movslq -0x44(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x44(%rbp),%rcx
lea    -0x2b0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13f4 <get_derivative_dynmat_at_q+0x284>
jmp    1463 <get_derivative_dynmat_at_q+0x2f3>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13e3 <get_derivative_dynmat_at_q+0x273>
jmp    1476 <get_derivative_dynmat_at_q+0x306>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13d2 <get_derivative_dynmat_at_q+0x262>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1ac3 <get_derivative_dynmat_at_q+0x953>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x30(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     14b8 <get_derivative_dynmat_at_q+0x348>
jmp    1ab5 <get_derivative_dynmat_at_q+0x945>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    150d <get_derivative_dynmat_at_q+0x39d>
movslq -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movslq -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14d5 <get_derivative_dynmat_at_q+0x365>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    -0x34(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1778 <get_derivative_dynmat_at_q+0x608>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    15a5 <get_derivative_dynmat_at_q+0x435>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x51,%ecx,%ecx
imul   $0x51,-0x34(%rbp),%edx
add    %edx,%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1543 <get_derivative_dynmat_at_q+0x3d3>
movsd  0xa5b(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  0xa53(%rip),%xmm1
mulsd  %xmm1,%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xa32(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  0xa2a(%rip),%xmm1
mulsd  %xmm1,%xmm0
call   1080 <cos@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    16cf <get_derivative_dynmat_at_q+0x55f>
movslq -0x44(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp,%rax,8)
movl   $0x0,-0x48(%rbp)
cmpl   $0x3,-0x48(%rbp)
jge    16bc <get_derivative_dynmat_at_q+0x54c>
mov    -0x28(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x9ac(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x51,%ecx,%ecx
imul   $0x51,-0x34(%rbp),%edx
add    %edx,%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x44(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    164c <get_derivative_dynmat_at_q+0x4dc>
jmp    16c1 <get_derivative_dynmat_at_q+0x551>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    162e <get_derivative_dynmat_at_q+0x4be>
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1765 <get_derivative_dynmat_at_q+0x5f5>
movslq -0x44(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movslq -0x44(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movslq -0x44(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16d6 <get_derivative_dynmat_at_q+0x566>
jmp    176a <get_derivative_dynmat_at_q+0x5fa>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1514 <get_derivative_dynmat_at_q+0x3a4>
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    184b <get_derivative_dynmat_at_q+0x6db>
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movslq -0x40(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movslq -0x40(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17d3 <get_derivative_dynmat_at_q+0x663>
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    1ab0 <get_derivative_dynmat_at_q+0x940>
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1a9d <get_derivative_dynmat_at_q+0x92d>
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x10(%rbp),%ecx
imul   $0x9,%ecx,%ecx
imul   $0x9,-0x3c(%rbp),%edx
add    %edx,%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
cmpl   $0x0,-0x54(%rbp)
je     18ea <get_derivative_dynmat_at_q+0x77a>
mov    -0x2c0(%rbp),%rax
imul   $0x9,-0x34(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x9,-0x38(%rbp),%edx
add    %edx,%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0x48(%rbp)
cmpl   $0x3,-0x48(%rbp)
jge    1a8a <get_derivative_dynmat_at_q+0x91a>
movsd  -0xd8(%rbp),%xmm0
ff
movslq -0x48(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm2
ff ff
movslq -0x48(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
movslq -0x48(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x48(%rbp),%rcx
lea    -0x2b0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x54(%rbp)
je     1a77 <get_derivative_dynmat_at_q+0x907>
mov    -0x2b8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x9,%ecx,%ecx
imul   $0x9,-0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   $0x9,-0x38(%rbp),%edx
add    %edx,%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe8(%rbp),%xmm2
ff
movslq -0x48(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2b8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x9,%ecx,%ecx
imul   $0x9,-0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   $0x9,-0x38(%rbp),%edx
add    %edx,%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movslq -0x48(%rbp),%rcx
lea    -0x2b0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a7c <get_derivative_dynmat_at_q+0x90c>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    18f1 <get_derivative_dynmat_at_q+0x781>
jmp    1a8f <get_derivative_dynmat_at_q+0x91f>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1863 <get_derivative_dynmat_at_q+0x6f3>
jmp    1aa2 <get_derivative_dynmat_at_q+0x932>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1852 <get_derivative_dynmat_at_q+0x6e2>
jmp    1ab5 <get_derivative_dynmat_at_q+0x945>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    148b <get_derivative_dynmat_at_q+0x31b>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    1bce <get_derivative_dynmat_at_q+0xa5e>
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    1bbb <get_derivative_dynmat_at_q+0xa4b>
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1ba8 <get_derivative_dynmat_at_q+0xa38>
mov    -0x3c(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   $0x12,%eax,%eax
imul   $0x3,-0x34(%rbp),%ecx
add    -0x40(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x6,%ecx,%ecx
add    %ecx,%eax
imul   $0x6,-0x38(%rbp),%ecx
add    %ecx,%eax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movslq -0x3c(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x3c(%rbp),%rcx
lea    -0x2b0(%rbp),%rax
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1aec <get_derivative_dynmat_at_q+0x97c>
jmp    1bad <get_derivative_dynmat_at_q+0xa3d>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1adb <get_derivative_dynmat_at_q+0x96b>
jmp    1bc0 <get_derivative_dynmat_at_q+0xa50>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1aca <get_derivative_dynmat_at_q+0x95a>
jmp    1bd3 <get_derivative_dynmat_at_q+0xa63>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1398 <get_derivative_dynmat_at_q+0x228>
jmp    1be6 <get_derivative_dynmat_at_q+0xa76>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1385 <get_derivative_dynmat_at_q+0x215>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    1d90 <get_derivative_dynmat_at_q+0xc20>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
imul   $0x3,-0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1d7d <get_derivative_dynmat_at_q+0xc0d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
imul   $0x3,-0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1d6a <get_derivative_dynmat_at_q+0xbfa>
mov    -0x34(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   $0x12,%eax,%eax
mov    -0x38(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x6,%ecx,%ecx
add    %ecx,%eax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   $0x12,%eax,%eax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x6,%ecx,%ecx
add    %ecx,%eax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x35a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x30a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c21 <get_derivative_dynmat_at_q+0xab1>
jmp    1d6f <get_derivative_dynmat_at_q+0xbff>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c0b <get_derivative_dynmat_at_q+0xa9b>
jmp    1d82 <get_derivative_dynmat_at_q+0xc12>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bfb <get_derivative_dynmat_at_q+0xa8b>
cmpl   $0x0,-0x54(%rbp)
je     1db2 <get_derivative_dynmat_at_q+0xc42>
mov    -0x2b8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x2c0(%rbp),%rdi
call   1030 <free@plt>
add    $0x2e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_derivative_dynmat_at_q>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x338,%rsp
mov    %r9,0x98(%rsp)
mov    %rcx,%r14
mov    %rdx,0x40(%rsp)
mov    %esi,%ebp
mov    %rdi,0x20(%rsp)
mov    0x398(%rsp),%r15
mov    0x390(%rsp),%r10
mov    0x388(%rsp),%r11
mov    0x380(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x378(%rsp),%rax
mov    %rax,0xd0(%rsp)
mov    0x370(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    $0x1,%r12b
test   %r15,%r15
mov    %r8,0x140(%rsp)
mov    %r10,0x30(%rsp)
mov    %r11,0x28(%rsp)
je     1249 <get_derivative_dynmat_at_q+0xd9>
mov    %r8,%rbx
mov    0x3a8(%rsp),%rax
mov    0x3a0(%rsp),%r13
test   %rax,%rax
movsd  %xmm0,0x70(%rsp)
mov    %rax,0x8(%rsp)
je     124e <get_derivative_dynmat_at_q+0xde>
movsd  (%rax),%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jg     127b <get_derivative_dynmat_at_q+0x10b>
mov    0x8(%rsp),%rax
movsd  0x8(%rax),%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jg     127b <get_derivative_dynmat_at_q+0x10b>
mov    0x8(%rsp),%rax
movsd  0x10(%rax),%xmm0
jmp    126e <get_derivative_dynmat_at_q+0xfe>
jmp    12fd <get_derivative_dynmat_at_q+0x18d>
movsd  (%rbx),%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jg     127b <get_derivative_dynmat_at_q+0x10b>
movsd  0x8(%rbx),%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jg     127b <get_derivative_dynmat_at_q+0x10b>
movsd  0x10(%rbx),%xmm0
call   1040 <fabs@plt>
test   %eax,%eax
jle    20c2 <get_derivative_dynmat_at_q+0xf52>
mov    %r13,0x18(%rsp)
mov    %rbx,%r13
mov    %ebp,%ebx
imul   %ebx,%ebx
imul   $0xd8,%ebx,%edi
call   1070 <malloc@plt>
mov    %r15,%r12
mov    %rax,%r15
shl    $0x3,%ebx
lea    (%rbx,%rbx,8),%edi
call   1070 <malloc@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0x70(%rsp),%xmm0
cvtsi2sdl 0x40(%rsp),%xmm1
divsd  %xmm1,%xmm0
sub    $0x8,%rsp
mov    %r15,%rdi
mov    %rax,%rsi
mov    %ebp,%edx
mov    0xa0(%rsp),%rcx
mov    0x88(%rsp),%r8
mov    %r13,%r9
push   0x10(%rsp)
mov    %rax,%r13
push   0x28(%rsp)
push   %r12
call   1050 <get_derivative_nac@plt>
add    $0x20,%rsp
xor    %r12d,%r12d
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%r11
mov    %rbp,%rax
mov    %rbp,0x10(%rsp)
test   %ebp,%ebp
mov    0x20(%rsp),%rbx
mov    %r13,0x50(%rsp)
jle    1db8 <get_derivative_dynmat_at_q+0xc48>
mov    0x10(%rsp),%rdx
mov    %edx,%eax
mov    %rax,0x58(%rsp)
mov    0x40(%rsp),%rsi
mov    %esi,%eax
mov    %rax,0x138(%rsp)
addq   $0x10,0xa0(%rsp)
mov    %edx,%eax
imul   %eax,%eax
lea    (%rax,%rax,1),%ecx
lea    (%rcx,%rcx,8),%r9d
lea    (%rdx,%rdx,8),%ecx
mov    %rcx,0x108(%rsp)
lea    (%rax,%rax,8),%ecx
lea    (%rsi,%rsi,8),%eax
mov    %eax,0x6c(%rsp)
lea    0x0(,%rdx,4),%eax
lea    (%rax,%rax,2),%esi
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,8),%edx
mov    %edx,0x68(%rsp)
lea    (%rax,%rax,2),%edi
xor    %eax,%eax
mov    %rax,0x48(%rsp)
xorpd  %xmm10,%xmm10
xorpd  %xmm11,%xmm11
xor    %eax,%eax
mov    %r9,%r8
xor    %edx,%edx
mov    %rdx,0x38(%rsp)
mov    %rsi,0x90(%rsp)
mov    %rdi,0x88(%rsp)
mov    %r9,0x118(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r8,0x120(%rsp)
mov    %rcx,0x128(%rsp)
mov    %rax,0x110(%rsp)
mov    %rax,0xb8(%rsp)
mov    %rcx,0xb0(%rsp)
mov    %r8,0xa8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x80(%rsp),%rax
mov    0x38(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  (%rax,%rbp,8),%xmm0
ucomisd %xmm10,%xmm0
mov    %rbp,0xc0(%rsp)
jb     1420 <get_derivative_dynmat_at_q+0x2b0>
sqrtsd %xmm0,%xmm0
jmp    1457 <get_derivative_dynmat_at_q+0x2e7>
nopl   0x0(%rax)
mov    %r9,%rbp
call   1090 <sqrt@plt>
mov    %rbp,%r9
mov    0xc0(%rsp),%rbp
xorpd  %xmm11,%xmm11
xorpd  %xmm10,%xmm10
mov    0x88(%rsp),%rdi
mov    0x90(%rsp),%rsi
mov    0x28(%rsp),%r11
mov    0x30(%rsp),%r10
movapd %xmm11,0x230(%rsp)
movapd %xmm11,0x150(%rsp)
movupd %xmm11,0x278(%rsp)
movupd %xmm11,0x198(%rsp)
movapd %xmm11,0x2c0(%rsp)
movapd %xmm11,0x1e0(%rsp)
movq   $0x0,0x240(%rsp)
movq   $0x0,0x160(%rsp)
movq   $0x0,0x288(%rsp)
movq   $0x0,0x1a8(%rsp)
movq   $0x0,0x2d0(%rsp)
movq   $0x0,0x1f0(%rsp)
movupd %xmm11,0x248(%rsp)
movupd %xmm11,0x168(%rsp)
movapd %xmm11,0x290(%rsp)
movapd %xmm11,0x1b0(%rsp)
movupd %xmm11,0x2d8(%rsp)
movupd %xmm11,0x1f8(%rsp)
movq   $0x0,0x258(%rsp)
movq   $0x0,0x178(%rsp)
movq   $0x0,0x2a0(%rsp)
movq   $0x0,0x1c0(%rsp)
movq   $0x0,0x2e8(%rsp)
movq   $0x0,0x208(%rsp)
movapd %xmm11,0x260(%rsp)
movapd %xmm11,0x180(%rsp)
movupd %xmm11,0x2a8(%rsp)
movupd %xmm11,0x1c8(%rsp)
movapd %xmm11,0x2f0(%rsp)
movapd %xmm11,0x210(%rsp)
movq   $0x0,0x270(%rsp)
movq   $0x0,0x190(%rsp)
movq   $0x0,0x2b8(%rsp)
movq   $0x0,0x1d8(%rsp)
movq   $0x0,0x300(%rsp)
movq   $0x0,0x220(%rsp)
cmpl   $0x0,0x40(%rsp)
jle    1b3d <get_derivative_dynmat_at_q+0x9cd>
xor    %eax,%eax
mov    %rax,0x60(%rsp)
xor    %ecx,%ecx
movsd  %xmm0,0x130(%rsp)
jmp    163f <get_derivative_dynmat_at_q+0x4cf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xc8(%rsp),%rcx
add    $0x1,%rcx
mov    0x60(%rsp),%rax
add    $0x9,%eax
mov    %rax,0x60(%rsp)
cmp    0x138(%rsp),%rcx
mov    0xc0(%rsp),%rbp
je     1b20 <get_derivative_dynmat_at_q+0x9b0>
mov    %rcx,0xc8(%rsp)
mov    (%r11,%rcx,4),%eax
cmp    (%r10,%rbp,4),%eax
jne    1610 <get_derivative_dynmat_at_q+0x4a0>
mov    0xc8(%rsp),%rcx
imul   0x58(%rsp),%rcx
add    0x38(%rsp),%rcx
mov    0xd0(%rsp),%rax
mov    %rcx,0xd8(%rsp)
mov    (%rax,%rcx,4),%eax
test   %eax,%eax
jle    18f0 <get_derivative_dynmat_at_q+0x780>
mov    0xd8(%rsp),%rbx
movabs $0x5100000000,%rax
imul   %rax,%rbx
sar    $0x1d,%rbx
add    0xa0(%rsp),%rbx
xorps  %xmm2,%xmm2
xorps  %xmm14,%xmm14
xor    %r13d,%r13d
xorps  %xmm12,%xmm12
xorpd  %xmm0,%xmm0
xorps  %xmm15,%xmm15
mov    0x98(%rsp),%rbp
nop
movaps %xmm2,0xf0(%rsp)
movsd  %xmm12,0x18(%rsp)
movaps %xmm15,0x70(%rsp)
movsd  %xmm14,0x8(%rsp)
movapd %xmm0,0x320(%rsp)
mov    0x140(%rsp),%rax
movsd  (%rax),%xmm3
movsd  0x8(%rax),%xmm1
mulsd  -0x10(%rbx),%xmm3
mulsd  -0x8(%rbx),%xmm1
addsd  %xmm10,%xmm3
movsd  0x10(%rax),%xmm0
mulsd  (%rbx),%xmm0
addsd  %xmm3,%xmm1
movaps %xmm2,0x310(%rsp)
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x18d6(%rip),%xmm0
movsd  %xmm0,0x148(%rsp)
call   1060 <sin@plt>
movapd %xmm0,0xe0(%rsp)
movsd  0x148(%rsp),%xmm0
call   1080 <cos@plt>
movapd 0x70(%rsp),%xmm15
movsd  0x8(%rsp),%xmm14
movapd 0x18ca(%rip),%xmm8
movapd 0x18b2(%rip),%xmm7
movsd  0x1892(%rip),%xmm3
xorpd  %xmm11,%xmm11
xorpd  %xmm10,%xmm10
movsd  0x0(%rbp),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0x10(%rbx),%xmm4
movsd  -0x8(%rbx),%xmm2
mulsd  %xmm4,%xmm1
addsd  %xmm10,%xmm1
movsd  0x8(%rbp),%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm1,%xmm5
movapd 0x320(%rsp),%xmm1
movsd  0x10(%rbp),%xmm9
mulsd  %xmm3,%xmm9
movsd  (%rbx),%xmm3
mulsd  %xmm3,%xmm9
addsd  %xmm5,%xmm9
movsd  0x18(%rbp),%xmm5
movsd  0x20(%rbp),%xmm6
movhpd 0x30(%rbp),%xmm5
mulpd  %xmm7,%xmm5
unpcklpd %xmm4,%xmm4
movhpd 0x38(%rbp),%xmm6
mulpd  %xmm5,%xmm4
mulpd  %xmm7,%xmm6
unpcklpd %xmm2,%xmm2
mulpd  %xmm6,%xmm2
movsd  0x28(%rbp),%xmm5
addpd  %xmm11,%xmm4
movhpd 0x40(%rbp),%xmm5
addpd  %xmm4,%xmm2
mulpd  %xmm7,%xmm5
unpcklpd %xmm3,%xmm3
mulpd  %xmm5,%xmm3
movapd 0xe0(%rsp),%xmm5
addpd  %xmm2,%xmm3
movapd 0xf0(%rsp),%xmm2
movapd %xmm3,%xmm4
unpckhpd %xmm3,%xmm4
xorpd  %xmm8,%xmm4
unpcklpd %xmm9,%xmm4
unpcklpd %xmm3,%xmm9
movapd %xmm5,%xmm13
unpcklpd %xmm0,%xmm13
mulpd  %xmm4,%xmm13
addsd  %xmm5,%xmm14
unpcklpd %xmm5,%xmm5
movapd %xmm9,%xmm4
mulpd  %xmm5,%xmm4
subpd  %xmm4,%xmm2
movsd  0x18(%rsp),%xmm12
addsd  %xmm0,%xmm12
unpcklpd %xmm0,%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm0,%xmm15
movapd %xmm13,%xmm0
addpd  %xmm1,%xmm0
add    $0x1,%r13
mov    0xd8(%rsp),%rax
mov    0xd0(%rsp),%rcx
movslq (%rcx,%rax,4),%rax
add    $0x18,%rbx
cmp    %rax,%r13
jl     16c0 <get_derivative_dynmat_at_q+0x550>
xorpd  %xmm8,%xmm9
movapd %xmm15,%xmm8
unpckhpd %xmm15,%xmm8
mulpd  %xmm5,%xmm9
addpd  0x310(%rsp),%xmm9
addpd  %xmm1,%xmm13
mov    0x50(%rsp),%r13
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%r11
movsd  0x130(%rsp),%xmm0
jmp    190e <get_derivative_dynmat_at_q+0x79e>
xorpd  %xmm9,%xmm9
xorpd  %xmm15,%xmm15
xorpd  %xmm8,%xmm8
xorpd  %xmm12,%xmm12
xorpd  %xmm14,%xmm14
xorpd  %xmm13,%xmm13
xorps  %xmm5,%xmm5
cvtsi2sd %eax,%xmm5
divsd  %xmm5,%xmm12
movapd %xmm9,%xmm3
divsd  %xmm5,%xmm3
movapd %xmm13,%xmm4
unpckhpd %xmm13,%xmm4
divsd  %xmm5,%xmm4
unpckhpd %xmm9,%xmm9
divsd  %xmm5,%xmm9
divsd  %xmm5,%xmm15
divsd  %xmm5,%xmm13
divsd  %xmm5,%xmm8
divsd  %xmm5,%xmm14
mov    0x38(%rsp),%rax
mov    (%r10,%rax,4),%eax
imul   0x6c(%rsp),%eax
add    0x60(%rsp),%eax
mov    0xb8(%rsp),%rcx
mov    0xb0(%rsp),%r9
mov    0xa8(%rsp),%rsi
lea    0x150(%rsp),%rdi
lea    0x230(%rsp),%rbx
xor    %r8d,%r8d
jmp    19b6 <get_derivative_dynmat_at_q+0x846>
xchg   %ax,%ax
add    $0x1,%r8
add    $0x18,%rbx
add    $0x18,%rdi
add    $0x3,%rsi
add    $0x3,%r9
add    $0x3,%rcx
add    $0x3,%rax
cmp    $0x3,%r8
je     1610 <get_derivative_dynmat_at_q+0x4a0>
xor    %ebp,%ebp
jmp    19ca <get_derivative_dynmat_at_q+0x85a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x3,%rbp
je     1990 <get_derivative_dynmat_at_q+0x820>
lea    (%rax,%rbp,1),%edx
movslq %edx,%rdx
movsd  (%r14,%rdx,8),%xmm5
divsd  %xmm0,%xmm5
test   %r12b,%r12b
jne    19ec <get_derivative_dynmat_at_q+0x87c>
lea    (%rcx,%rbp,1),%edx
movslq %edx,%rdx
addsd  0x0(%r13,%rdx,8),%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm3,%xmm6
addsd  (%rbx,%rbp,8),%xmm6
movsd  %xmm6,(%rbx,%rbp,8)
movapd %xmm5,%xmm7
mulsd  %xmm4,%xmm7
addsd  (%rdi,%rbp,8),%xmm7
movsd  %xmm7,(%rdi,%rbp,8)
test   %r12b,%r12b
jne    1a41 <get_derivative_dynmat_at_q+0x8d1>
lea    (%rcx,%rbp,1),%edx
movslq %edx,%rdx
movsd  (%r15,%rdx,8),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mulsd  %xmm14,%xmm2
addsd  %xmm7,%xmm2
movsd  %xmm2,(%rdi,%rbp,8)
movapd %xmm5,%xmm6
mulsd  %xmm9,%xmm6
addsd  0x48(%rbx,%rbp,8),%xmm6
movsd  %xmm6,0x48(%rbx,%rbp,8)
movapd %xmm5,%xmm7
mulsd  %xmm15,%xmm7
addsd  0x48(%rdi,%rbp,8),%xmm7
movsd  %xmm7,0x48(%rdi,%rbp,8)
test   %r12b,%r12b
jne    1a9f <get_derivative_dynmat_at_q+0x92f>
lea    (%r9,%rbp,1),%edx
movslq %edx,%rdx
movsd  (%r15,%rdx,8),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,0x48(%rbx,%rbp,8)
mulsd  %xmm14,%xmm2
addsd  %xmm7,%xmm2
movsd  %xmm2,0x48(%rdi,%rbp,8)
movapd %xmm5,%xmm6
mulsd  %xmm13,%xmm6
addsd  0x90(%rbx,%rbp,8),%xmm6
movsd  %xmm6,0x90(%rbx,%rbp,8)
mulsd  %xmm8,%xmm5
addsd  0x90(%rdi,%rbp,8),%xmm5
movsd  %xmm5,0x90(%rdi,%rbp,8)
test   %r12b,%r12b
jne    19c0 <get_derivative_dynmat_at_q+0x850>
lea    (%rsi,%rbp,1),%edx
movslq %edx,%rdx
movsd  (%r15,%rdx,8),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,0x90(%rbx,%rbp,8)
mulsd  %xmm14,%xmm2
addsd  %xmm5,%xmm2
movsd  %xmm2,0x90(%rdi,%rbp,8)
jmp    19c0 <get_derivative_dynmat_at_q+0x850>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rbx
mov    0x118(%rsp),%r9
mov    0x90(%rsp),%rsi
mov    0x88(%rsp),%rdi
lea    0x0(%rbp,%rbp,2),%eax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,2),%ecx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  0x230(%rsp,%rax,1),%xmm0
movslq %ecx,%rcx
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x150(%rsp,%rax,1),%xmm0
lea    0x1(%rcx),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    0x2(%rcx),%edx
movsd  0x238(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x158(%rsp,%rax,1),%xmm0
lea    0x3(%rcx),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    0x4(%rcx),%edx
movsd  0x240(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x160(%rsp,%rax,1),%xmm0
lea    0x5(%rcx),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    (%rdi,%rcx,1),%edx
movsd  0x248(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x168(%rsp,%rax,1),%xmm0
lea    0x1(%rdi,%rcx,1),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    0x2(%rdi,%rcx,1),%edx
movsd  0x250(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x170(%rsp,%rax,1),%xmm0
lea    0x3(%rdi,%rcx,1),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    0x4(%rdi,%rcx,1),%edx
movsd  0x258(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x178(%rsp,%rax,1),%xmm0
lea    0x5(%rdi,%rcx,1),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    (%rsi,%rcx,1),%edx
movsd  0x260(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x180(%rsp,%rax,1),%xmm0
lea    0x1(%rsi,%rcx,1),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    0x2(%rsi,%rcx,1),%edx
movsd  0x268(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x188(%rsp,%rax,1),%xmm0
lea    0x3(%rsi,%rcx,1),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    0x4(%rsi,%rcx,1),%edx
movsd  0x270(%rsp,%rax,1),%xmm0
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x190(%rsp,%rax,1),%xmm0
lea    0x5(%rsi,%rcx,1),%edx
movslq %edx,%rdx
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x48,%rax
add    %r9d,%ecx
cmp    $0xd8,%rax
jne    1b50 <get_derivative_dynmat_at_q+0x9e0>
add    $0x1,%rbp
addq   $0x9,0xa8(%rsp)
addq   $0x9,0xb0(%rsp)
addq   $0x9,0xb8(%rsp)
cmp    0x58(%rsp),%rbp
mov    0x128(%rsp),%rcx
mov    0x120(%rsp),%rdx
jne    13f0 <get_derivative_dynmat_at_q+0x280>
mov    0x38(%rsp),%rax
mov    %r9,%rbp
mov    %rax,%r9
add    $0x1,%r9
mov    0x108(%rsp),%rax
add    %rax,%rdx
add    %rax,%rcx
mov    %rdx,%r8
mov    0x110(%rsp),%rdx
add    %rax,%rdx
mov    0x48(%rsp),%rax
add    0x68(%rsp),%eax
mov    %rax,0x48(%rsp)
mov    %rdx,%rax
mov    %r9,%rdx
mov    %r9,0x38(%rsp)
cmp    0x58(%rsp),%r9
mov    %rbp,%r9
jne    13b0 <get_derivative_dynmat_at_q+0x240>
mov    0x10(%rsp),%rax
lea    (%rax,%rax,2),%edx
test   %edx,%edx
jle    208a <get_derivative_dynmat_at_q+0xf1a>
mov    0x10(%rsp),%rcx
mov    %ecx,%eax
imul   %eax,%eax
mov    %rax,0xe0(%rsp)
add    %eax,%eax
lea    (%rax,%rax,8),%eax
mov    %eax,0xf0(%rsp)
mov    %edx,0x70(%rsp)
mov    %edx,%eax
add    %ecx,%ecx
mov    %rcx,0x18(%rsp)
lea    (%rcx,%rcx,2),%ebp
mov    %rax,0x8(%rsp)
lea    (%rax,%rax,1),%rcx
mov    $0x1,%r13d
xor    %r10d,%r10d
movsd  0x1200(%rip),%xmm0
movapd 0x1218(%rip),%xmm1
xor    %r11d,%r11d
mov    0x20(%rsp),%r14
jmp    1e42 <get_derivative_dynmat_at_q+0xcd2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x2,%r13d
add    %ebp,%r10d
cmp    0x8(%rsp),%r11
je     1ec1 <get_derivative_dynmat_at_q+0xd51>
cmpl   $0x0,0x10(%rsp)
jle    1e30 <get_derivative_dynmat_at_q+0xcc0>
mov    %r10d,%eax
add    $0x1,%rax
movslq %r10d,%rsi
lea    (%r14,%rsi,8),%rdi
xor    %esi,%esi
mov    %r13d,%r8d
nopl   0x0(%rax)
lea    -0x1(%r8),%r9d
movslq %r9d,%rdx
movsd  (%r14,%rdx,8),%xmm2
addsd  (%rdi,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rdi,%rsi,8)
movslq %r8d,%r8
lea    (%rax,%rsi,1),%ebx
movslq %ebx,%rbx
movsd  (%r14,%rbx,8),%xmm3
subsd  (%r14,%r8,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%r14,%rbx,8)
movsd  %xmm2,(%r14,%rdx,8)
movsd  (%r14,%rbx,8),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,(%r14,%r8,8)
add    %ebp,%r8d
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    1e60 <get_derivative_dynmat_at_q+0xcf0>
jmp    1e30 <get_derivative_dynmat_at_q+0xcc0>
mov    0x70(%rsp),%r11d
cmp    $0x2,%r11d
mov    0x50(%rsp),%r13
jl     208a <get_derivative_dynmat_at_q+0xf1a>
mov    0x10(%rsp),%rdx
lea    (%rdx,%rdx,8),%eax
lea    (%rax,%rax,1),%r13d
add    $0x6,%r13d
imul   %edx,%r13d
mov    0x18(%rsp),%rax
lea    (%rax,%rax,2),%r9d
mov    0xf0(%rsp),%r14d
add    $0x3,%r14d
lea    0x1(%r13),%r10
mov    $0x1,%r8d
mov    0x20(%rsp),%rsi
jmp    1f25 <get_derivative_dynmat_at_q+0xdb5>
nop
add    $0x1,%r8
add    %r9d,%r13d
add    $0x2,%r14d
add    %r9,%r10
cmp    0x8(%rsp),%r8
je     1f9a <get_derivative_dynmat_at_q+0xe2a>
cmpl   $0x0,0x10(%rsp)
jle    1f10 <get_derivative_dynmat_at_q+0xda0>
movslq %r13d,%rax
lea    (%rsi,%rax,8),%rax
mov    %r14d,%edi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdi),%edx
movslq %edx,%rdx
movsd  (%rsi,%rdx,8),%xmm2
addsd  (%rax,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rax,%rbp,8)
movslq %edi,%rdi
lea    (%r10,%rbp,1),%ebx
movslq %ebx,%rbx
movsd  (%rsi,%rbx,8),%xmm3
subsd  (%rsi,%rdi,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%rsi,%rbx,8)
movsd  %xmm2,(%rsi,%rdx,8)
movsd  (%rsi,%rbx,8),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,(%rsi,%rdi,8)
add    $0x2,%rbp
add    %r9d,%edi
cmp    %rbp,%rcx
jne    1f40 <get_derivative_dynmat_at_q+0xdd0>
jmp    1f10 <get_derivative_dynmat_at_q+0xda0>
cmp    $0x3,%r11d
mov    0x50(%rsp),%r13
jl     208a <get_derivative_dynmat_at_q+0xf1a>
mov    0xe0(%rsp),%rax
lea    (%rax,%rax,8),%eax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,1),%r11
mov    0x10(%rsp),%rcx
lea    (%rcx,%rcx,8),%edx
lea    0xc(,%rdx,4),%r9d
imul   %ecx,%r9d
mov    0x18(%rsp),%rcx
lea    (%rcx,%rcx,2),%r14d
lea    0x5(,%rax,4),%r8d
lea    0x1(%r9),%rbp
mov    $0x2,%r10d
mov    0x20(%rsp),%rsi
jmp    2015 <get_derivative_dynmat_at_q+0xea5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
add    %r14d,%r9d
add    $0x2,%r8d
add    %r14,%rbp
cmp    0x8(%rsp),%r10
je     208a <get_derivative_dynmat_at_q+0xf1a>
cmpl   $0x0,0x10(%rsp)
jle    2000 <get_derivative_dynmat_at_q+0xe90>
movslq %r9d,%rax
lea    (%rsi,%rax,8),%rax
mov    %r8d,%edx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdx),%ebx
movslq %ebx,%rbx
movsd  (%rsi,%rbx,8),%xmm2
addsd  (%rax,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rax,%rdi,8)
movslq %edx,%rdx
lea    0x0(%rbp,%rdi,1),%ecx
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm3
subsd  (%rsi,%rdx,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%rsi,%rcx,8)
movsd  %xmm2,(%rsi,%rbx,8)
movsd  (%rsi,%rcx,8),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,(%rsi,%rdx,8)
add    $0x2,%rdi
add    %r14d,%edx
cmp    %rdi,%r11
jne    2030 <get_derivative_dynmat_at_q+0xec0>
jmp    2000 <get_derivative_dynmat_at_q+0xe90>
test   %r12b,%r12b
je     20a1 <get_derivative_dynmat_at_q+0xf31>
add    $0x338,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
add    $0x338,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
jmp    12f3 <get_derivative_dynmat_at_q+0x183>

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

LLVM IR (-O2):
define void @get_derivative_dynmat_at_q(double* nocapture %0, i32 %1, i32 %2, double* nocapture %3, double* %4, double* %5, double* nocapture %6, i32* nocapture %7, double* %8, i32* nocapture %9, i32* nocapture %10, double %11, double* %12, double* %13, double* %14) {
%16 = alloca [3 x [3 x [3 x double]]]
%17 = alloca [3 x [3 x [3 x double]]]
%18 = bitcast [3 x [3 x [3 x double]]]* %16 to i8*
%19 = bitcast [3 x [3 x [3 x double]]]* %17 to i8*
%20 = icmp eq double* %12, null
br i1 %20, label %65, label %21
21: ; preds = %15
%22 = icmp eq double* %14, null
br i1 %22, label %37, label %23
23: ; preds = %21
%24 = load double, double* %14
%25 = tail call i32 @fabs(double %24)
%26 = icmp slt i32 %25, 1
br i1 %26, label %27, label %51
27: ; preds = %23
%28 = getelementptr inbounds double, double* %14, i64 1
%29 = load double, double* %28
%30 = tail call i32 @fabs(double %29)
%31 = icmp slt i32 %30, 1
br i1 %31, label %32, label %51
32: ; preds = %27
%33 = getelementptr inbounds double, double* %14, i64 2
%34 = load double, double* %33
%35 = tail call i32 @fabs(double %34)
%36 = icmp slt i32 %35, 1
br i1 %36, label %65, label %51
37: ; preds = %21
%38 = load double, double* %4
%39 = tail call i32 @fabs(double %38)
%40 = icmp slt i32 %39, 1
br i1 %40, label %41, label %51
41: ; preds = %37
%42 = getelementptr inbounds double, double* %4, i64 1
%43 = load double, double* %42
%44 = tail call i32 @fabs(double %43)
%45 = icmp slt i32 %44, 1
br i1 %45, label %46, label %51
46: ; preds = %41
%47 = getelementptr inbounds double, double* %4, i64 2
%48 = load double, double* %47
%49 = tail call i32 @fabs(double %48)
%50 = icmp slt i32 %49, 1
br i1 %50, label %65, label %51
51: ; preds = %37, %41, %23, %27, %32, %46
%52 = shl i32 %1, 3
%53 = mul i32 %52, %1
%54 = mul i32 %53, 27
%55 = tail call i64 @malloc(i32 %54)
%56 = inttoptr i64 %55 to double*
%57 = mul i32 %53, 9
%58 = tail call i64 @malloc(i32 %57)
%59 = inttoptr i64 %58 to double*
%60 = sitofp i32 %1 to double
%61 = fmul double %60, %11
%62 = sitofp i32 %2 to double
%63 = fdiv double %61, %62
%64 = tail call i32 @get_derivative_nac(double* %56, double* %59, i32 %1, double* %5, double* %8, double* %4, double* %12, double* %13, double* %14, double %63)
br label %65
65: ; preds = %15, %32, %51, %46
%66 = phi i1 [ false, %51 ], [ true, %46 ], [ true, %32 ], [ true, %15 ]
%67 = phi double* [ %56, %51 ], [ undef, %46 ], [ undef, %32 ], [ undef, %15 ]
%68 = phi double* [ %59, %51 ], [ undef, %46 ], [ undef, %32 ], [ undef, %15 ]
%69 = icmp sgt i32 %1, 0
br i1 %69, label %70, label %158
70: ; preds = %65
%71 = icmp sgt i32 %2, 0
%72 = mul i32 %1, 18
%73 = zext i32 %1 to i64
%74 = zext i32 %1 to i64
%75 = zext i32 %2 to i64
%76 = getelementptr inbounds double, double* %4, i64 1
%77 = getelementptr inbounds double, double* %4, i64 2
%78 = getelementptr inbounds double, double* %5, i64 1
%79 = getelementptr inbounds double, double* %5, i64 2
%80 = getelementptr inbounds double, double* %5, i64 3
%81 = getelementptr inbounds double, double* %5, i64 4
%82 = getelementptr inbounds double, double* %5, i64 5
%83 = getelementptr inbounds double, double* %5, i64 6
%84 = getelementptr inbounds double, double* %5, i64 7
%85 = getelementptr inbounds double, double* %5, i64 8
%86 = shl i32 %1, 1
%87 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 1, i64 0, i64 0
%88 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 1, i64 0, i64 0
%89 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 2, i64 0, i64 0
%90 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 2, i64 0, i64 0
%91 = bitcast [3 x [3 x [3 x double]]]* %16 to <2 x double>*
%92 = bitcast [3 x [3 x [3 x double]]]* %17 to <2 x double>*
%93 = bitcast double* %87 to <2 x double>*
%94 = bitcast double* %88 to <2 x double>*
%95 = bitcast double* %89 to <2 x double>*
%96 = bitcast double* %90 to <2 x double>*
%97 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 0, i64 0, i64 2
%98 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 0, i64 0, i64 2
%99 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 1, i64 0, i64 2
%100 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 1, i64 0, i64 2
%101 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 2, i64 0, i64 2
%102 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 2, i64 0, i64 2
%103 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 0, i64 1, i64 0
%104 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 0, i64 1, i64 0
%105 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 1, i64 1, i64 0
%106 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 1, i64 1, i64 0
%107 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 2, i64 1, i64 0
%108 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 2, i64 1, i64 0
%109 = bitcast double* %103 to <2 x double>*
%110 = bitcast double* %104 to <2 x double>*
%111 = bitcast double* %105 to <2 x double>*
%112 = bitcast double* %106 to <2 x double>*
%113 = bitcast double* %107 to <2 x double>*
%114 = bitcast double* %108 to <2 x double>*
%115 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 0, i64 1, i64 2
%116 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 0, i64 1, i64 2
%117 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 1, i64 1, i64 2
%118 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 1, i64 1, i64 2
%119 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 2, i64 1, i64 2
%120 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 2, i64 1, i64 2
%121 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 0, i64 2, i64 0
%122 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 0, i64 2, i64 0
%123 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 1, i64 2, i64 0
%124 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 1, i64 2, i64 0
%125 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 2, i64 2, i64 0
%126 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 2, i64 2, i64 0
%127 = bitcast double* %121 to <2 x double>*
%128 = bitcast double* %122 to <2 x double>*
%129 = bitcast double* %123 to <2 x double>*
%130 = bitcast double* %124 to <2 x double>*
%131 = bitcast double* %125 to <2 x double>*
%132 = bitcast double* %126 to <2 x double>*
%133 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 0, i64 2, i64 2
%134 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 0, i64 2, i64 2
%135 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 1, i64 2, i64 2
%136 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 1, i64 2, i64 2
%137 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 2, i64 2, i64 2
%138 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 2, i64 2, i64 2
br label %139
139: ; preds = %523, %70
%140 = phi i64 [ 0, %70 ], [ %524, %523 ]
%141 = getelementptr inbounds double, double* %8, i64 %140
%142 = getelementptr inbounds i32, i32* %10, i64 %140
%143 = trunc i64 %140 to i32
%144 = mul i32 %143, %1
%145 = mul nuw nsw i64 %140, 3
%146 = add i32 %143, %1
%147 = mul i32 %146, %1
%148 = add i32 %86, %143
%149 = mul i32 %148, %1
%150 = trunc i64 %145 to i32
%151 = mul i32 %150, 6
%152 = trunc i64 %145 to i32
%153 = mul i32 %152, 6
%154 = add i32 %153, 6
%155 = trunc i64 %145 to i32
%156 = mul i32 %155, 6
%157 = add i32 %156, 12
br label %164
158: ; preds = %523, %65
%159 = mul i32 %1, 3
%160 = mul i32 %1, %1
%161 = mul i32 %160, 18
%162 = mul i32 %1, 6
%163 = icmp sgt i32 %159, 0
br i1 %163, label %526, label %664
164: ; preds = %139, %520
%165 = phi i64 [ 0, %139 ], [ %521, %520 ]
%166 = load double, double* %141
%167 = getelementptr inbounds double, double* %8, i64 %165
%168 = load double, double* %167
%169 = fmul double %166, %168
%170 = tail call double @sqrt(double %169)
store <2 x double> zeroinitializer, <2 x double>* %91
store <2 x double> zeroinitializer, <2 x double>* %92
store <2 x double> zeroinitializer, <2 x double>* %93
store <2 x double> zeroinitializer, <2 x double>* %94
store <2 x double> zeroinitializer, <2 x double>* %95
store <2 x double> zeroinitializer, <2 x double>* %96
store double 0.000000e+00, double* %97
store double 0.000000e+00, double* %98
store double 0.000000e+00, double* %99
store double 0.000000e+00, double* %100
store double 0.000000e+00, double* %101
store double 0.000000e+00, double* %102
store <2 x double> zeroinitializer, <2 x double>* %109
store <2 x double> zeroinitializer, <2 x double>* %110
store <2 x double> zeroinitializer, <2 x double>* %111
store <2 x double> zeroinitializer, <2 x double>* %112
store <2 x double> zeroinitializer, <2 x double>* %113
store <2 x double> zeroinitializer, <2 x double>* %114
store double 0.000000e+00, double* %115
store double 0.000000e+00, double* %116
store double 0.000000e+00, double* %117
store double 0.000000e+00, double* %118
store double 0.000000e+00, double* %119
store double 0.000000e+00, double* %120
store <2 x double> zeroinitializer, <2 x double>* %127
store <2 x double> zeroinitializer, <2 x double>* %128
store <2 x double> zeroinitializer, <2 x double>* %129
store <2 x double> zeroinitializer, <2 x double>* %130
store <2 x double> zeroinitializer, <2 x double>* %131
store <2 x double> zeroinitializer, <2 x double>* %132
store double 0.000000e+00, double* %133
store double 0.000000e+00, double* %134
store double 0.000000e+00, double* %135
store double 0.000000e+00, double* %136
store double 0.000000e+00, double* %137
store double 0.000000e+00, double* %138
br i1 %71, label %173, label %171
171: ; preds = %164
%172 = trunc i64 %165 to i32
br label %182
173: ; preds = %164
%174 = getelementptr inbounds i32, i32* %10, i64 %165
%175 = trunc i64 %165 to i32
%176 = add i32 %144, %175
%177 = mul i32 %176, 9
%178 = add i32 %147, %175
%179 = mul i32 %178, 9
%180 = add i32 %149, %175
%181 = mul i32 %180, 9
br label %185
182: ; preds = %379, %171
%183 = phi i32 [ %172, %171 ], [ %175, %379 ]
%184 = mul nsw i32 %183, 6
br label %382
185: ; preds = %173, %379
%186 = phi i64 [ 0, %173 ], [ %380, %379 ]
%187 = getelementptr inbounds i32, i32* %9, i64 %186
%188 = load i32, i32* %187
%189 = load i32, i32* %174
%190 = icmp eq i32 %188, %189
br i1 %190, label %191, label %379
191: ; preds = %185
%192 = mul nsw i64 %186, %73
%193 = add nuw nsw i64 %192, %140
%194 = getelementptr inbounds i32, i32* %7, i64 %193
%195 = load i32, i32* %194
%196 = icmp sgt i32 %195, 0
br i1 %196, label %197, label %287
197: ; preds = %191
%198 = mul i64 %193, 347892350976
%199 = ashr exact i64 %198, 32
br label %200
200: ; preds = %197, %200
%201 = phi i64 [ 0, %197 ], [ %279, %200 ]
%202 = phi double [ 0.000000e+00, %197 ], [ %278, %200 ]
%203 = phi double [ 0.000000e+00, %197 ], [ %226, %200 ]
%204 = phi <4 x double> [ zeroinitializer, %197 ], [ %274, %200 ]
%205 = phi <2 x double> [ zeroinitializer, %197 ], [ %277, %200 ]
%206 = mul nuw nsw i64 %201, 3
%207 = add nsw i64 %206, %199
%208 = load double, double* %4
%209 = getelementptr inbounds double, double* %6, i64 %207
%210 = load double, double* %209
%211 = tail call double @llvm.fmuladd.f64(double %208, double %210, double 0.000000e+00)
%212 = load double, double* %76
%213 = add nsw i64 %207, 1
%214 = getelementptr inbounds double, double* %6, i64 %213
%215 = load double, double* %214
%216 = tail call double @llvm.fmuladd.f64(double %212, double %215, double %211)
%217 = load double, double* %77
%218 = add nsw i64 %207, 2
%219 = getelementptr inbounds double, double* %6, i64 %218
%220 = load double, double* %219
%221 = tail call double @llvm.fmuladd.f64(double %217, double %220, double %216)
%222 = fmul double %221, 2.000000e+00
%223 = fmul double %222, 0x400921FB54442D18
%224 = tail call double @sin(double %223)
%225 = tail call double @cos(double %223)
%226 = fadd double %203, %225
%227 = load double, double* %5
%228 = fmul double %227, 0x401921FB54442D18
%229 = load double, double* %209
%230 = tail call double @llvm.fmuladd.f64(double %228, double %229, double 0.000000e+00)
%231 = load double, double* %78
%232 = fmul double %231, 0x401921FB54442D18
%233 = load double, double* %214
%234 = tail call double @llvm.fmuladd.f64(double %232, double %233, double %230)
%235 = load double, double* %79
%236 = fmul double %235, 0x401921FB54442D18
%237 = load double, double* %219
%238 = tail call double @llvm.fmuladd.f64(double %236, double %237, double %234)
%239 = load double, double* %80
%240 = load double, double* %81
%241 = load double, double* %82
%242 = load double, double* %83
%243 = insertelement <2 x double> poison, double %239, i64 0
%244 = insertelement <2 x double> %243, double %242, i64 1
%245 = fmul <2 x double> %244, <double 0x401921FB54442D18, double 0x401921FB54442D18>
%246 = insertelement <2 x double> poison, double %229, i64 0
%247 = shufflevector <2 x double> %246, <2 x double> poison, <2 x i32> zeroinitializer
%248 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %245, <2 x double> %247, <2 x double> zeroinitializer)
%249 = load double, double* %84
%250 = insertelement <2 x double> poison, double %240, i64 0
%251 = insertelement <2 x double> %250, double %249, i64 1
%252 = fmul <2 x double> %251, <double 0x401921FB54442D18, double 0x401921FB54442D18>
%253 = insertelement <2 x double> poison, double %233, i64 0
%254 = shufflevector <2 x double> %253, <2 x double> poison, <2 x i32> zeroinitializer
%255 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %252, <2 x double> %254, <2 x double> %248)
%256 = load double, double* %85
%257 = insertelement <2 x double> poison, double %241, i64 0
%258 = insertelement <2 x double> %257, double %256, i64 1
%259 = fmul <2 x double> %258, <double 0x401921FB54442D18, double 0x401921FB54442D18>
%260 = insertelement <2 x double> poison, double %237, i64 0
%261 = shufflevector <2 x double> %260, <2 x double> poison, <2 x i32> zeroinitializer
%262 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %259, <2 x double> %261, <2 x double> %255)
%263 = insertelement <2 x double> poison, double %238, i64 0
%264 = shufflevector <2 x double> %263, <2 x double> %262, <2 x i32> <i32 0, i32 2>
%265 = fneg <2 x double> %264
%266 = extractelement <2 x double> %262, i64 1
%267 = fneg double %266
%268 = shufflevector <2 x double> %265, <2 x double> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%269 = insertelement <4 x double> %268, double %267, i64 2
%270 = insertelement <4 x double> %269, double %238, i64 3
%271 = insertelement <4 x double> poison, double %224, i64 0
%272 = insertelement <4 x double> %271, double %225, i64 1
%273 = shufflevector <4 x double> %272, <4 x double> poison, <4 x i32> <i32 0, i32 0, i32 0, i32 1>
%274 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %270, <4 x double> %273, <4 x double> %204)
%275 = insertelement <2 x double> poison, double %225, i64 0
%276 = shufflevector <2 x double> %275, <2 x double> poison, <2 x i32> zeroinitializer
%277 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %262, <2 x double> %276, <2 x double> %205)
%278 = fadd double %202, %224
%279 = add nuw nsw i64 %201, 1
%280 = load i32, i32* %194
%281 = sext i32 %280 to i64
%282 = icmp slt i64 %279, %281
br i1 %282, label %200, label %283
283: ; preds = %200
%284 = extractelement <2 x double> %277, i64 1
%285 = extractelement <2 x double> %277, i64 0
%286 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %270, <4 x double> %273, <4 x double> %204)
br label %287
287: ; preds = %283, %191
%288 = phi double [ 0.000000e+00, %191 ], [ %285, %283 ]
%289 = phi double [ 0.000000e+00, %191 ], [ %284, %283 ]
%290 = phi double [ 0.000000e+00, %191 ], [ %226, %283 ]
%291 = phi double [ 0.000000e+00, %191 ], [ %278, %283 ]
%292 = phi i32 [ %195, %191 ], [ %280, %283 ]
%293 = phi <4 x double> [ zeroinitializer, %191 ], [ %286, %283 ]
%294 = sitofp i32 %292 to double
%295 = fdiv double %290, %294
%296 = extractelement <4 x double> %293, i64 0
%297 = fdiv double %296, %294
%298 = extractelement <4 x double> %293, i64 3
%299 = fdiv double %298, %294
%300 = extractelement <4 x double> %293, i64 1
%301 = fdiv double %300, %294
%302 = fdiv double %288, %294
%303 = extractelement <4 x double> %293, i64 2
%304 = fdiv double %303, %294
%305 = fdiv double %289, %294
%306 = fdiv double %291, %294
%307 = load i32, i32* %142
%308 = mul nsw i32 %307, %2
%309 = trunc i64 %186 to i32
%310 = add i32 %308, %309
%311 = mul i32 %310, 9
br label %312
312: ; preds = %287, %376
%313 = phi i64 [ 0, %287 ], [ %377, %376 ]
%314 = mul nuw nsw i64 %313, 3
br label %315
315: ; preds = %312, %373
%316 = phi i64 [ 0, %312 ], [ %374, %373 ]
%317 = add nuw nsw i64 %316, %314
%318 = trunc i64 %317 to i32
%319 = add i32 %311, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %3, i64 %320
%322 = load double, double* %321
%323 = fdiv double %322, %170
br i1 %66, label %330, label %324
324: ; preds = %315
%325 = add i32 %177, %318
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %68, i64 %326
%328 = load double, double* %327
%329 = fadd double %323, %328
br label %330
330: ; preds = %324, %315
%331 = phi double [ %329, %324 ], [ %323, %315 ]
%332 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 0, i64 %313, i64 %316
%333 = load double, double* %332
%334 = tail call double @llvm.fmuladd.f64(double %331, double %297, double %333)
store double %334, double* %332
%335 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 0, i64 %313, i64 %316
%336 = load double, double* %335
%337 = tail call double @llvm.fmuladd.f64(double %331, double %299, double %336)
store double %337, double* %335
br i1 %66, label %345, label %338
338: ; preds = %330
%339 = add i32 %177, %318
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds double, double* %67, i64 %340
%342 = load double, double* %341
%343 = tail call double @llvm.fmuladd.f64(double %342, double %295, double %334)
store double %343, double* %332
%344 = tail call double @llvm.fmuladd.f64(double %342, double %306, double %337)
store double %344, double* %335
br label %345
345: ; preds = %330, %338
%346 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 1, i64 %313, i64 %316
%347 = load double, double* %346
%348 = tail call double @llvm.fmuladd.f64(double %331, double %301, double %347)
store double %348, double* %346
%349 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 1, i64 %313, i64 %316
%350 = load double, double* %349
%351 = tail call double @llvm.fmuladd.f64(double %331, double %302, double %350)
store double %351, double* %349
br i1 %66, label %359, label %352
352: ; preds = %345
%353 = add i32 %179, %318
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double, double* %67, i64 %354
%356 = load double, double* %355
%357 = tail call double @llvm.fmuladd.f64(double %356, double %295, double %348)
store double %357, double* %346
%358 = tail call double @llvm.fmuladd.f64(double %356, double %306, double %351)
store double %358, double* %349
br label %359
359: ; preds = %352, %345
%360 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 2, i64 %313, i64 %316
%361 = load double, double* %360
%362 = tail call double @llvm.fmuladd.f64(double %331, double %304, double %361)
store double %362, double* %360
%363 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 2, i64 %313, i64 %316
%364 = load double, double* %363
%365 = tail call double @llvm.fmuladd.f64(double %331, double %305, double %364)
store double %365, double* %363
br i1 %66, label %373, label %366
366: ; preds = %359
%367 = add i32 %181, %318
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds double, double* %67, i64 %368
%370 = load double, double* %369
%371 = tail call double @llvm.fmuladd.f64(double %370, double %295, double %362)
store double %371, double* %360
%372 = tail call double @llvm.fmuladd.f64(double %370, double %306, double %365)
store double %372, double* %363
br label %373
373: ; preds = %366, %359
%374 = add nuw nsw i64 %316, 1
%375 = icmp eq i64 %374, 3
br i1 %375, label %376, label %315
376: ; preds = %373
%377 = add nuw nsw i64 %313, 1
%378 = icmp eq i64 %377, 3
br i1 %378, label %379, label %312
379: ; preds = %376, %185
%380 = add nuw nsw i64 %186, 1
%381 = icmp eq i64 %380, %75
br i1 %381, label %182, label %185
382: ; preds = %182, %382
%383 = phi i64 [ 0, %182 ], [ %518, %382 ]
%384 = trunc i64 %383 to i32
%385 = mul i32 %72, %384
%386 = add i32 %151, %385
%387 = mul i32 %386, %1
%388 = add i32 %387, %184
%389 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 0, i64 0
%390 = load double, double* %389
%391 = sext i32 %388 to i64
%392 = getelementptr inbounds double, double* %0, i64 %391
%393 = load double, double* %392
%394 = fadd double %390, %393
store double %394, double* %392
%395 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 0, i64 0
%396 = load double, double* %395
%397 = or i32 %388, 1
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds double, double* %0, i64 %398
%400 = load double, double* %399
%401 = fadd double %396, %400
store double %401, double* %399
%402 = add i32 %388, 2
%403 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 0, i64 1
%404 = load double, double* %403
%405 = sext i32 %402 to i64
%406 = getelementptr inbounds double, double* %0, i64 %405
%407 = load double, double* %406
%408 = fadd double %404, %407
store double %408, double* %406
%409 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 0, i64 1
%410 = load double, double* %409
%411 = or i32 %402, 1
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds double, double* %0, i64 %412
%414 = load double, double* %413
%415 = fadd double %410, %414
store double %415, double* %413
%416 = add i32 %388, 4
%417 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 0, i64 2
%418 = load double, double* %417
%419 = sext i32 %416 to i64
%420 = getelementptr inbounds double, double* %0, i64 %419
%421 = load double, double* %420
%422 = fadd double %418, %421
store double %422, double* %420
%423 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 0, i64 2
%424 = load double, double* %423
%425 = or i32 %416, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds double, double* %0, i64 %426
%428 = load double, double* %427
%429 = fadd double %424, %428
store double %429, double* %427
%430 = add i32 %154, %385
%431 = mul i32 %430, %1
%432 = add i32 %431, %184
%433 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 1, i64 0
%434 = load double, double* %433
%435 = sext i32 %432 to i64
%436 = getelementptr inbounds double, double* %0, i64 %435
%437 = load double, double* %436
%438 = fadd double %434, %437
store double %438, double* %436
%439 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 1, i64 0
%440 = load double, double* %439
%441 = or i32 %432, 1
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %0, i64 %442
%444 = load double, double* %443
%445 = fadd double %440, %444
store double %445, double* %443
%446 = add i32 %432, 2
%447 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 1, i64 1
%448 = load double, double* %447
%449 = sext i32 %446 to i64
%450 = getelementptr inbounds double, double* %0, i64 %449
%451 = load double, double* %450
%452 = fadd double %448, %451
store double %452, double* %450
%453 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 1, i64 1
%454 = load double, double* %453
%455 = or i32 %446, 1
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds double, double* %0, i64 %456
%458 = load double, double* %457
%459 = fadd double %454, %458
store double %459, double* %457
%460 = add i32 %432, 4
%461 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 1, i64 2
%462 = load double, double* %461
%463 = sext i32 %460 to i64
%464 = getelementptr inbounds double, double* %0, i64 %463
%465 = load double, double* %464
%466 = fadd double %462, %465
store double %466, double* %464
%467 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 1, i64 2
%468 = load double, double* %467
%469 = or i32 %460, 1
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %0, i64 %470
%472 = load double, double* %471
%473 = fadd double %468, %472
store double %473, double* %471
%474 = add i32 %157, %385
%475 = mul i32 %474, %1
%476 = add i32 %475, %184
%477 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 2, i64 0
%478 = load double, double* %477
%479 = sext i32 %476 to i64
%480 = getelementptr inbounds double, double* %0, i64 %479
%481 = load double, double* %480
%482 = fadd double %478, %481
store double %482, double* %480
%483 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 2, i64 0
%484 = load double, double* %483
%485 = or i32 %476, 1
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %0, i64 %486
%488 = load double, double* %487
%489 = fadd double %484, %488
store double %489, double* %487
%490 = add i32 %476, 2
%491 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 2, i64 1
%492 = load double, double* %491
%493 = sext i32 %490 to i64
%494 = getelementptr inbounds double, double* %0, i64 %493
%495 = load double, double* %494
%496 = fadd double %492, %495
store double %496, double* %494
%497 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 2, i64 1
%498 = load double, double* %497
%499 = or i32 %490, 1
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %0, i64 %500
%502 = load double, double* %501
%503 = fadd double %498, %502
store double %503, double* %501
%504 = add i32 %476, 4
%505 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %16, i64 0, i64 %383, i64 2, i64 2
%506 = load double, double* %505
%507 = sext i32 %504 to i64
%508 = getelementptr inbounds double, double* %0, i64 %507
%509 = load double, double* %508
%510 = fadd double %506, %509
store double %510, double* %508
%511 = getelementptr inbounds [3 x [3 x [3 x double]]], [3 x [3 x [3 x double]]]* %17, i64 0, i64 %383, i64 2, i64 2
%512 = load double, double* %511
%513 = or i32 %504, 1
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %0, i64 %514
%516 = load double, double* %515
%517 = fadd double %512, %516
store double %517, double* %515
%518 = add nuw nsw i64 %383, 1
%519 = icmp eq i64 %518, 3
br i1 %519, label %520, label %382
520: ; preds = %382
%521 = add nuw nsw i64 %165, 1
%522 = icmp eq i64 %521, %74
br i1 %522, label %523, label %164
523: ; preds = %520
%524 = add nuw nsw i64 %140, 1
%525 = icmp eq i64 %524, %74
br i1 %525, label %158, label %139
526: ; preds = %158
%527 = zext i32 %159 to i64
br label %528
528: ; preds = %526, %566
%529 = phi i64 [ 0, %526 ], [ %567, %566 ]
br i1 %69, label %530, label %566
530: ; preds = %528
%531 = trunc i64 %529 to i32
%532 = mul i32 %162, %531
%533 = trunc i64 %529 to i32
%534 = shl i32 %533, 1
%535 = sext i32 %532 to i64
br label %536
536: ; preds = %530, %536
%537 = phi i64 [ 0, %530 ], [ %564, %536 ]
%538 = trunc i64 %537 to i32
%539 = shl nuw nsw i64 %537, 1
%540 = shl nuw nsw i32 %538, 1
%541 = add nsw i64 %539, %535
%542 = add nsw i32 %532, %540
%543 = mul i32 %162, %538
%544 = add i32 %534, %543
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %0, i64 %545
%547 = load double, double* %546
%548 = getelementptr inbounds double, double* %0, i64 %541
%549 = load double, double* %548
%550 = fadd double %547, %549
%551 = fmul double %550, 5.000000e-01
store double %551, double* %548
%552 = or i32 %544, 1
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double, double* %0, i64 %553
%555 = load double, double* %554
%556 = or i32 %542, 1
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds double, double* %0, i64 %557
%559 = load double, double* %558
%560 = fsub double %559, %555
%561 = fmul double %560, 5.000000e-01
store double %561, double* %558
store double %551, double* %546
%562 = load double, double* %558
%563 = fneg double %562
store double %563, double* %554
%564 = add nuw nsw i64 %537, 1
%565 = icmp eq i64 %564, %527
br i1 %565, label %566, label %536
566: ; preds = %536, %528
%567 = add nuw nsw i64 %529, 1
%568 = icmp eq i64 %567, %527
br i1 %568, label %569, label %528
569: ; preds = %566
%570 = icmp sgt i32 %159, 1
br i1 %570, label %571, label %664
571: ; preds = %569
%572 = zext i32 %159 to i64
br label %573
573: ; preds = %613, %571
%574 = phi i64 [ 1, %571 ], [ %614, %613 ]
br i1 %69, label %575, label %613
575: ; preds = %573
%576 = trunc i64 %574 to i32
%577 = mul i32 %162, %576
%578 = add nsw i32 %577, %161
%579 = trunc i64 %574 to i32
%580 = shl i32 %579, 1
%581 = add i32 %580, %161
%582 = sext i32 %578 to i64
br label %583
583: ; preds = %583, %575
%584 = phi i64 [ 0, %575 ], [ %611, %583 ]
%585 = trunc i64 %584 to i32
%586 = shl nuw nsw i64 %584, 1
%587 = shl nuw nsw i32 %585, 1
%588 = add nsw i64 %586, %582
%589 = add nsw i32 %578, %587
%590 = mul i32 %162, %585
%591 = add i32 %581, %590
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds double, double* %0, i64 %592
%594 = load double, double* %593
%595 = getelementptr inbounds double, double* %0, i64 %588
%596 = load double, double* %595
%597 = fadd double %594, %596
%598 = fmul double %597, 5.000000e-01
store double %598, double* %595
%599 = or i32 %591, 1
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds double, double* %0, i64 %600
%602 = load double, double* %601
%603 = or i32 %589, 1
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %0, i64 %604
%606 = load double, double* %605
%607 = fsub double %606, %602
%608 = fmul double %607, 5.000000e-01
store double %608, double* %605
store double %598, double* %593
%609 = load double, double* %605
%610 = fneg double %609
store double %610, double* %601
%611 = add nuw nsw i64 %584, 1
%612 = icmp eq i64 %611, %572
br i1 %612, label %613, label %583
613: ; preds = %583, %573
%614 = add nuw nsw i64 %574, 1
%615 = icmp eq i64 %614, %572
br i1 %615, label %616, label %573
616: ; preds = %613
%617 = icmp sgt i32 %159, 2
br i1 %617, label %618, label %664
618: ; preds = %616
%619 = mul i32 %160, 36
%620 = zext i32 %159 to i64
br label %621
621: ; preds = %661, %618
%622 = phi i64 [ 2, %618 ], [ %662, %661 ]
br i1 %69, label %623, label %661
623: ; preds = %621
%624 = trunc i64 %622 to i32
%625 = mul i32 %162, %624
%626 = add nsw i32 %625, %619
%627 = trunc i64 %622 to i32
%628 = shl i32 %627, 1
%629 = add i32 %628, %619
%630 = sext i32 %626 to i64
br label %631
631: ; preds = %631, %623
%632 = phi i64 [ 0, %623 ], [ %659, %631 ]
%633 = trunc i64 %632 to i32
%634 = shl nuw nsw i64 %632, 1
%635 = shl nuw nsw i32 %633, 1
%636 = add nsw i64 %634, %630
%637 = add nsw i32 %626, %635
%638 = mul i32 %162, %633
%639 = add i32 %629, %638
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds double, double* %0, i64 %640
%642 = load double, double* %641
%643 = getelementptr inbounds double, double* %0, i64 %636
%644 = load double, double* %643
%645 = fadd double %642, %644
%646 = fmul double %645, 5.000000e-01
store double %646, double* %643
%647 = or i32 %639, 1
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %0, i64 %648
%650 = load double, double* %649
%651 = or i32 %637, 1
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %0, i64 %652
%654 = load double, double* %653
%655 = fsub double %654, %650
%656 = fmul double %655, 5.000000e-01
store double %656, double* %653
store double %646, double* %641
%657 = load double, double* %653
%658 = fneg double %657
store double %658, double* %649
%659 = add nuw nsw i64 %632, 1
%660 = icmp eq i64 %659, %620
br i1 %660, label %661, label %631
661: ; preds = %631, %621
%662 = add nuw nsw i64 %622, 1
%663 = icmp eq i64 %662, %620
br i1 %663, label %664, label %621
664: ; preds = %661, %158, %569, %616
br i1 %66, label %668, label %665
665: ; preds = %664
%666 = tail call i32 @free(double* %67)
%667 = tail call i32 @free(double* %68)
br label %668
668: ; preds = %665, %664
ret void
}