#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 */
typedef int uint64_t;

/* Variables and functions */
int abs(int);
double compute_cre_des_sign(int, int, int *, int);
int *compute_occ_list(int *, int, int, int);
double fabs(double);
int /*<<< orphan*/ free(int *);
int *get_double_excitation(int *, int *, int);
int *get_single_excitation(int *, int *, int);
int *malloc(int);
int n_excitations(int *, int *, int);
void contract_h_c(double *h1, double *eri, int norb, int neleca, int nelecb,
                  uint64_t *strs, double *civec, double *hdiag, uint64_t ndet,
                  double *ci1) {
  int *ts = malloc(sizeof(int) * ndet);
#pragma omp parallel
  {
    size_t ip, jp, p;
    int nset = (norb + 63) / 64;
    ts[0] = 0;
    uint64_t *str1a = strs;
    uint64_t *str1b = strs + nset;
#pragma omp for schedule(static)
    for (ip = 1; ip < ndet; ++ip) {
      uint64_t *stria = strs + ip * 2 * nset;
      uint64_t *strib = strs + ip * 2 * nset + nset;
      ts[ip] = (n_excitations(stria, str1a, nset) +
                n_excitations(strib, str1b, nset));
    }
#pragma omp for schedule(static)
    for (ip = 0; ip < ndet; ++ip) {
      for (jp = 0; jp < ndet; ++jp) {
        if (abs(ts[ip] - ts[jp]) < 3) {
          uint64_t *stria = strs + ip * 2 * nset;
          uint64_t *strib = strs + ip * 2 * nset + nset;
          uint64_t *strja = strs + jp * 2 * nset;
          uint64_t *strjb = strs + jp * 2 * nset + nset;
          int n_excit_a = n_excitations(stria, strja, nset);
          int n_excit_b = n_excitations(strib, strjb, nset);
          if (ip == jp) {
            ci1[ip] += hdiag[ip] * civec[ip];
          } else if ((n_excit_a + n_excit_b) == 1) {
            int *ia;
            if (n_excit_b == 0) {
              ia = get_single_excitation(stria, strja, nset);
              int i = ia[0];
              int a = ia[1];
              double sign = compute_cre_des_sign(a, i, stria, nset);
              int *occsa = compute_occ_list(stria, nset, norb, neleca);
              int *occsb = compute_occ_list(strib, nset, norb, nelecb);
              double fai = h1[a * norb + i];
              for (p = 0; p < neleca; ++p) {
                int k = occsa[p];
                int kkai =
                    k * norb * norb * norb + k * norb * norb + a * norb + i;
                int kiak =
                    k * norb * norb * norb + i * norb * norb + a * norb + k;
                fai += eri[kkai] - eri[kiak];
              }
              for (p = 0; p < nelecb; ++p) {
                int k = occsb[p];
                int kkai =
                    k * norb * norb * norb + k * norb * norb + a * norb + i;
                fai += eri[kkai];
              }
              if (fabs(fai) > 1.0E-14)
                ci1[ip] += sign * fai * civec[jp];
              free(occsa);
              free(occsb);
            } else if (n_excit_a == 0) {
              ia = get_single_excitation(strib, strjb, nset);
              int i = ia[0];
              int a = ia[1];
              double sign = compute_cre_des_sign(a, i, strib, nset);
              int *occsa = compute_occ_list(stria, nset, norb, neleca);
              int *occsb = compute_occ_list(strib, nset, norb, nelecb);
              double fai = h1[a * norb + i];
              for (p = 0; p < nelecb; ++p) {
                int k = occsb[p];
                int kkai =
                    k * norb * norb * norb + k * norb * norb + a * norb + i;
                int kiak =
                    k * norb * norb * norb + i * norb * norb + a * norb + k;
                fai += eri[kkai] - eri[kiak];
              }
              for (p = 0; p < neleca; ++p) {
                int k = occsa[p];
                int kkai =
                    k * norb * norb * norb + k * norb * norb + a * norb + i;
                fai += eri[kkai];
              }
              if (fabs(fai) > 1.0E-14)
                ci1[ip] += sign * fai * civec[jp];
              free(occsa);
              free(occsb);
            }
            free(ia);
          } else if ((n_excit_a + n_excit_b) == 2) {
            int i, j, a, b;
            if (n_excit_b == 0) {
              int *ijab = get_double_excitation(stria, strja, nset);
              i = ijab[0];
              j = ijab[1];
              a = ijab[2];
              b = ijab[3];
              double v, sign;
              int ajbi =
                  a * norb * norb * norb + j * norb * norb + b * norb + i;
              int aibj =
                  a * norb * norb * norb + i * norb * norb + b * norb + j;
              if (a > j || i > b) {
                v = eri[ajbi] - eri[aibj];
                sign = compute_cre_des_sign(b, i, stria, nset);
                sign *= compute_cre_des_sign(a, j, stria, nset);
              } else {
                v = eri[aibj] - eri[ajbi];
                sign = compute_cre_des_sign(b, j, stria, nset);
                sign *= compute_cre_des_sign(a, i, stria, nset);
              }
              if (fabs(v) > 1.0E-14)
                ci1[ip] += sign * v * civec[jp];
              free(ijab);
            } else if (n_excit_a == 0) {
              int *ijab = get_double_excitation(strib, strjb, nset);
              i = ijab[0];
              j = ijab[1];
              a = ijab[2];
              b = ijab[3];
              double v, sign;
              int ajbi =
                  a * norb * norb * norb + j * norb * norb + b * norb + i;
              int aibj =
                  a * norb * norb * norb + i * norb * norb + b * norb + j;
              if (a > j || i > b) {
                v = eri[ajbi] - eri[aibj];
                sign = compute_cre_des_sign(b, i, strib, nset);
                sign *= compute_cre_des_sign(a, j, strib, nset);
              } else {
                v = eri[aibj] - eri[ajbi];
                sign = compute_cre_des_sign(b, j, strib, nset);
                sign *= compute_cre_des_sign(a, i, strib, nset);
              }
              if (fabs(v) > 1.0E-14)
                ci1[ip] += sign * v * civec[jp];
              free(ijab);
            } else {
              int *ia = get_single_excitation(stria, strja, nset);
              int *jb = get_single_excitation(strib, strjb, nset);
              i = ia[0];
              a = ia[1];
              j = jb[0];
              b = jb[1];
              double v =
                  eri[a * norb * norb * norb + i * norb * norb + b * norb + j];
              double sign = compute_cre_des_sign(a, i, stria, nset);
              sign *= compute_cre_des_sign(b, j, strib, nset);
              if (fabs(v) > 1.0E-14)
                ci1[ip] += sign * v * civec[jp];
              free(ia);
              free(jb);
            }
          }
        }
      }
    }
  }
  free(ts);
}


x86 assembly (clang, -O0):
<contract_h_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movslq 0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
add    $0x3f,%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    12a5 <contract_h_c+0x125>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x4c(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x4c(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1050 <n_excitations@plt>
mov    %eax,-0x194(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1050 <n_excitations@plt>
mov    -0x194(%rbp),%edx
add    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1201 <contract_h_c+0x81>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    2000 <contract_h_c+0xe80>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq 0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    1fea <contract_h_c+0xe6a>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    (%rax,%rcx,4),%edi
call   1040 <abs@plt>
cmp    $0x3,%eax
jge    1fd4 <contract_h_c+0xe54>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x4c(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x4c(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x4c(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x4c(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1050 <n_excitations@plt>
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1050 <n_excitations@plt>
mov    %eax,-0x98(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    140c <contract_h_c+0x28c>
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1fcf <contract_h_c+0xe4f>
mov    -0x94(%rbp),%eax
add    -0x98(%rbp),%eax
cmp    $0x1,%eax
jne    1990 <contract_h_c+0x810>
cmpl   $0x0,-0x98(%rbp)
jne    16d0 <contract_h_c+0x550>
mov    -0x78(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x78(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0xa4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    15bf <contract_h_c+0x43f>
mov    -0xb8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0xcc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xa8(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xcc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0xa4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xa8(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xcc(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xd4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    14e5 <contract_h_c+0x365>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jae    1657 <contract_h_c+0x4d7>
mov    -0xc0(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0xd8(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xa8(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    15c7 <contract_h_c+0x447>
movsd  -0xc8(%rbp),%xmm0
ff
movaps 0x19aa(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x198e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    16b3 <contract_h_c+0x533>
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
jmp    197f <contract_h_c+0x7ff>
cmpl   $0x0,-0x94(%rbp)
jne    197a <contract_h_c+0x7fa>
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xa0(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe4(%rbp),%edi
mov    -0xe0(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x78(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0xf8(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0x100(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xe4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0xe0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jae    186e <contract_h_c+0x6ee>
mov    -0x100(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x10c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xe4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x10c(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0xe0(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xe4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x10c(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x114(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1794 <contract_h_c+0x614>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    1906 <contract_h_c+0x786>
mov    -0xf8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x118(%rbp)
mov    -0x118(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x118(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xe4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x11c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1876 <contract_h_c+0x6f6>
movsd  -0x108(%rbp),%xmm0
ff
movaps 0x16fb(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x16df(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1962 <contract_h_c+0x7e2>
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0x108(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
jmp    197f <contract_h_c+0x7ff>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
jmp    1fca <contract_h_c+0xe4a>
mov    -0x94(%rbp),%eax
add    -0x98(%rbp),%eax
cmp    $0x2,%eax
jne    1fc5 <contract_h_c+0xe45>
cmpl   $0x0,-0x98(%rbp)
jne    1bf5 <contract_h_c+0xa75>
mov    -0x78(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1070 <get_double_excitation@plt>
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x120(%rbp)
mov    -0x138(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x124(%rbp)
mov    -0x138(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x128(%rbp)
mov    -0x138(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x128(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x124(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x12c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x120(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x128(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x120(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x12c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x124(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x128(%rbp),%eax
cmp    -0x124(%rbp),%eax
jg     1aa3 <contract_h_c+0x923>
mov    -0x120(%rbp),%eax
cmp    -0x12c(%rbp),%eax
jle    1b18 <contract_h_c+0x998>
mov    -0x10(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x150(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x12c(%rbp),%edi
mov    -0x120(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x128(%rbp),%edi
mov    -0x124(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
jmp    1b88 <contract_h_c+0xa08>
mov    -0x10(%rbp),%rax
movslq -0x150(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x12c(%rbp),%edi
mov    -0x124(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x128(%rbp),%edi
mov    -0x120(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movaps 0x1479(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x145d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1be4 <contract_h_c+0xa64>
movsd  -0x148(%rbp),%xmm0
ff
mulsd  -0x140(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x138(%rbp),%rdi
call   1030 <free@plt>
jmp    1fc0 <contract_h_c+0xe40>
cmpl   $0x0,-0x94(%rbp)
jne    1e45 <contract_h_c+0xcc5>
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1070 <get_double_excitation@plt>
mov    %rax,-0x158(%rbp)
mov    -0x158(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x120(%rbp)
mov    -0x158(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x124(%rbp)
mov    -0x158(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x128(%rbp)
mov    -0x158(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x128(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x124(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x12c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x120(%rbp),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x128(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x120(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x12c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x124(%rbp),%eax
mov    %eax,-0x170(%rbp)
mov    -0x128(%rbp),%eax
cmp    -0x124(%rbp),%eax
jg     1cf3 <contract_h_c+0xb73>
mov    -0x120(%rbp),%eax
cmp    -0x12c(%rbp),%eax
jle    1d68 <contract_h_c+0xbe8>
mov    -0x10(%rbp),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x170(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x12c(%rbp),%edi
mov    -0x120(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x128(%rbp),%edi
mov    -0x124(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
jmp    1dd8 <contract_h_c+0xc58>
mov    -0x10(%rbp),%rax
movslq -0x170(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x16c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x12c(%rbp),%edi
mov    -0x124(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x128(%rbp),%edi
mov    -0x120(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movaps 0x1229(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x120d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1e34 <contract_h_c+0xcb4>
movsd  -0x168(%rbp),%xmm0
ff
mulsd  -0x160(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
jmp    1fbb <contract_h_c+0xe3b>
mov    -0x78(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0x178(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0x180(%rbp)
mov    -0x178(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x120(%rbp)
mov    -0x178(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x128(%rbp)
mov    -0x180(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x124(%rbp)
mov    -0x180(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x128(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x120(%rbp),%edx
imul   -0x14(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
mov    -0x12c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x124(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x128(%rbp),%edi
mov    -0x120(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x12c(%rbp),%edi
mov    -0x124(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
movaps 0x10ba(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x109e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1fa3 <contract_h_c+0xe23>
movsd  -0x190(%rbp),%xmm0
ff
mulsd  -0x188(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x178(%rbp),%rdi
call   1030 <free@plt>
mov    -0x180(%rbp),%rdi
call   1030 <free@plt>
jmp    1fc0 <contract_h_c+0xe40>
jmp    1fc5 <contract_h_c+0xe45>
jmp    1fca <contract_h_c+0xe4a>
jmp    1fcf <contract_h_c+0xe4f>
jmp    1fd4 <contract_h_c+0xe54>
jmp    1fd9 <contract_h_c+0xe59>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12c6 <contract_h_c+0x146>
jmp    1fef <contract_h_c+0xe6f>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12ad <contract_h_c+0x12d>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x1a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<contract_h_c>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0x18(%rsp)
mov    %r8d,0x24(%rsp)
mov    %ecx,0x14(%rsp)
mov    %edx,%ebx
mov    %rsi,0x28(%rsp)
mov    %rdi,0xa8(%rsp)
movslq 0x130(%rsp),%r13
mov    0x138(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x128(%rsp),%rax
mov    %rax,0xe0(%rsp)
mov    0x120(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x0(,%r13,4),%edi
call   1050 <malloc@plt>
mov    %rax,%rdi
lea    0x3f(%rbx),%eax
mov    %rbx,%rcx
mov    %rbx,0x48(%rsp)
lea    0x7e(%rbx),%r12d
test   %eax,%eax
cmovns %eax,%r12d
sar    $0x6,%r12d
movl   $0x0,(%rdi)
movslq %r12d,%rax
mov    %rax,0x98(%rsp)
cmp    $0x2,%r13
mov    %rdi,0x38(%rsp)
jb     1293 <contract_h_c+0x123>
mov    0x98(%rsp),%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,4),%rax
mov    %rax,0x8(%rsp)
lea    (%rcx,%rcx,2),%rax
lea    (%rsi,%rax,4),%rbp
lea    0x0(,%rcx,8),%rax
mov    %rax,0x40(%rsp)
lea    (%rsi,%rcx,8),%rbx
mov    $0x1,%r14d
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    0x18(%rsp),%rsi
mov    %r12d,%edx
call   1040 <n_excitations@plt>
mov    %eax,%r15d
mov    %rbp,%rdi
mov    0x8(%rsp),%rsi
mov    %r12d,%edx
call   1040 <n_excitations@plt>
mov    0x38(%rsp),%rdi
add    %r15d,%eax
mov    %eax,(%rdi,%r14,4)
add    $0x1,%r14
mov    0x40(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
cmp    %r14,%r13
jne    1250 <contract_h_c+0xe0>
mov    %r12d,0x4(%rsp)
test   %r13d,%r13d
mov    0x18(%rsp),%rdx
mov    0x48(%rsp),%rax
je     1b40 <contract_h_c+0x9d0>
mov    0x98(%rsp),%rcx
add    %rcx,%rcx
mov    %rcx,0xc0(%rsp)
mov    %eax,%ebp
imul   %eax,%ebp
mov    %ebp,%ecx
imul   %eax,%ecx
mov    %ecx,0x6c(%rsp)
mov    0x24(%rsp),%esi
cmp    $0x2,%esi
mov    $0x1,%eax
mov    $0x1,%ecx
cmovae %esi,%ecx
movslq %ecx,%r8
mov    0x14(%rsp),%ecx
cmp    $0x2,%ecx
cmovae %ecx,%eax
movslq %eax,%rsi
cmp    $0x2,%r13
mov    $0x1,%ebx
cmovae %r13,%rbx
mov    %rsi,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xc8(%rsp)
mov    %r8,0xb8(%rsp)
and    $0xfffffffffffffffe,%r8
mov    %r8,0xd0(%rsp)
xor    %r13d,%r13d
mov    %ebp,(%rsp)
mov    %rsi,0xa0(%rsp)
mov    %rbx,0x50(%rsp)
jmp    134d <contract_h_c+0x1dd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
cmp    %rbx,%r13
je     1b40 <contract_h_c+0x9d0>
mov    0xc0(%rsp),%rax
imul   %r13,%rax
lea    (%rdx,%rax,4),%rcx
mov    0x98(%rsp),%rax
mov    %rcx,0x40(%rsp)
lea    (%rcx,%rax,4),%r12
xor    %r15d,%r15d
mov    %r12,0x30(%rsp)
mov    %r13,0x8(%rsp)
jmp    13c6 <contract_h_c+0x256>
nopl   (%rax)
mov    0xe0(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
mov    0x58(%rsp),%rax
mulsd  (%rax,%r13,8),%xmm0
mov    0x60(%rsp),%rax
addsd  (%rax,%r13,8),%xmm0
movsd  %xmm0,(%rax,%r13,8)
mov    0x18(%rsp),%rdx
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%rbx
add    $0x1,%r15
cmp    %rbx,%r15
je     1340 <contract_h_c+0x1d0>
mov    (%rdi,%r13,4),%eax
sub    (%rdi,%r15,4),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    $0x2,%ecx
ja     13b9 <contract_h_c+0x249>
mov    0xc0(%rsp),%rax
imul   %r15,%rax
lea    (%rdx,%rax,4),%rbp
mov    0x98(%rsp),%rax
lea    0x0(,%rax,4),%r14
add    %rbp,%r14
mov    0x40(%rsp),%rdi
mov    %rbp,%rsi
mov    0x4(%rsp),%r13d
mov    %r13d,%edx
call   1040 <n_excitations@plt>
mov    %eax,%ebx
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r13d,%edx
mov    0x8(%rsp),%r13
call   1040 <n_excitations@plt>
cmp    %r15,%r13
je     1380 <contract_h_c+0x210>
lea    (%rax,%rbx,1),%ecx
cmp    $0x2,%ecx
je     1543 <contract_h_c+0x3d3>
cmp    $0x1,%ecx
jne    13aa <contract_h_c+0x23a>
test   %eax,%eax
je     1646 <contract_h_c+0x4d6>
test   %ebx,%ebx
jne    1b2e <contract_h_c+0x9be>
mov    %r12,%rdi
mov    %r14,%rsi
mov    0x4(%rsp),%ebp
mov    %ebp,%edx
call   1090 <get_single_excitation@plt>
mov    (%rax),%r13d
mov    %r12,%rbx
mov    %rax,0xb0(%rsp)
mov    0x4(%rax),%r12d
mov    %r12d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x80(%rsp)
mov    0x40(%rsp),%rdi
mov    %ebp,%esi
mov    0x48(%rsp),%r14
mov    %r14d,%edx
mov    0x14(%rsp),%ecx
call   1080 <compute_occ_list@plt>
mov    %rax,0x70(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
mov    0x24(%rsp),%ebx
mov    %ebx,%ecx
call   1080 <compute_occ_list@plt>
imul   %r14d,%r12d
lea    (%r12,%r13,1),%r10d
movslq %r10d,%rcx
mov    0xa8(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
test   %ebx,%ebx
je     1a39 <contract_h_c+0x8c9>
mov    (%rsp),%ebx
imul   %ebx,%r13d
xor    %ecx,%ecx
mov    0x28(%rsp),%rbp
mov    0xa0(%rsp),%r8
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rcx,4),%edx
mov    %ebx,%esi
imul   %edx,%esi
lea    (%r10,%rsi,1),%edi
imul   %r14d,%esi
add    %esi,%edi
add    %r12d,%esi
add    %r13d,%esi
add    %edx,%esi
movslq %edi,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm1
movslq %esi,%rdx
subsd  0x0(%rbp,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,0xb8(%rsp)
jne    1500 <contract_h_c+0x390>
jmp    1a49 <contract_h_c+0x8d9>
test   %eax,%eax
mov    0x4(%rsp),%eax
je     172e <contract_h_c+0x5be>
test   %ebx,%ebx
je     1848 <contract_h_c+0x6d8>
mov    0x40(%rsp),%r12
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %eax,%ebp
mov    %eax,%edx
call   1090 <get_single_excitation@plt>
mov    %rax,%rbx
mov    0x30(%rsp),%rdi
mov    %r14,%rsi
mov    %ebp,%edx
call   1090 <get_single_excitation@plt>
mov    %rax,%r14
mov    (%rbx),%esi
mov    %rbx,0x70(%rsp)
mov    0x4(%rbx),%edi
mov    (%rax),%r13d
mov    0x4(%rax),%ebx
mov    %edi,%eax
mov    0x48(%rsp),%rcx
imul   %ecx,%eax
add    %esi,%eax
imul   %ecx,%eax
add    %ebx,%eax
imul   %ecx,%eax
add    %r13d,%eax
cltq
mov    0x28(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movapd %xmm0,0x80(%rsp)
mov    %r12,%rdx
mov    0x30(%rsp),%r12
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0xd8(%rsp)
mov    %ebx,%edi
mov    %r13d,%esi
mov    %r12,%rdx
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movapd 0x80(%rsp),%xmm2
movapd %xmm2,%xmm1
andpd  0xa08(%rip),%xmm1
ucomisd 0xa10(%rip),%xmm1
mov    0x8(%rsp),%r13
jbe    1634 <contract_h_c+0x4c4>
movsd  0xd8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm2
mov    0x58(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm2
mov    0x60(%rsp),%rax
addsd  (%rax,%r13,8),%xmm2
movsd  %xmm2,(%rax,%r13,8)
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
jmp    1b36 <contract_h_c+0x9c6>
mov    0x40(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    0x4(%rsp),%ebp
mov    %ebp,%edx
call   1090 <get_single_excitation@plt>
mov    (%rax),%r14d
mov    %rax,0xb0(%rsp)
mov    0x4(%rax),%r13d
mov    %r13d,%edi
mov    %r14d,%esi
mov    %rbx,%rdx
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x80(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
mov    0x48(%rsp),%rbx
mov    %ebx,%edx
mov    0x14(%rsp),%ecx
call   1080 <compute_occ_list@plt>
mov    %rax,0x70(%rsp)
mov    %r12,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
mov    0x24(%rsp),%ecx
call   1080 <compute_occ_list@plt>
imul   %ebx,%r13d
lea    (%r14,%r13,1),%r8d
movslq %r8d,%rcx
mov    0xa8(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
cmpl   $0x0,0x14(%rsp)
je     1958 <contract_h_c+0x7e8>
mov    (%rsp),%r9d
imul   %r9d,%r14d
xor    %ecx,%ecx
mov    0x28(%rsp),%r12
mov    0xa0(%rsp),%r10
mov    0x70(%rsp),%rdi
nopl   (%rax)
mov    (%rdi,%rcx,4),%edx
mov    %r9d,%esi
imul   %edx,%esi
lea    (%r8,%rsi,1),%ebp
imul   %ebx,%esi
add    %esi,%ebp
add    %r13d,%esi
add    %r14d,%esi
add    %edx,%esi
movslq %ebp,%rdx
movsd  (%r12,%rdx,8),%xmm1
movslq %esi,%rdx
subsd  (%r12,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r10
jne    16f0 <contract_h_c+0x580>
jmp    1966 <contract_h_c+0x7f6>
mov    0x40(%rsp),%r12
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1060 <get_double_excitation@plt>
mov    %rax,%r13
mov    (%rax),%ebx
mov    0x4(%rax),%eax
mov    0x8(%r13),%r14d
mov    0xc(%r13),%edi
mov    0x6c(%rsp),%edx
imul   %r14d,%edx
mov    (%rsp),%ebp
mov    %ebp,%esi
imul   %eax,%esi
mov    %edi,%ecx
imul   0x48(%rsp),%ecx
add    %edx,%ecx
add    %ecx,%esi
add    %ebx,%esi
mov    %ebp,%edx
imul   %ebx,%edx
add    %eax,%ecx
add    %edx,%ecx
cmp    %eax,%r14d
setg   %r8b
cmp    %edi,%ebx
setg   %dl
or     %r8b,%dl
mov    %ecx,%edx
cmovne %esi,%edx
cmove  %esi,%ecx
mov    %eax,%esi
cmovne %ebx,%esi
cmovne %eax,%ebx
movslq %edx,%rax
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movslq %ecx,%rax
subsd  (%rdx,%rax,8),%xmm0
movapd %xmm0,0x70(%rsp)
mov    %r12,%rdx
mov    0x4(%rsp),%ebp
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x80(%rsp)
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12,%rdx
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movapd 0x70(%rsp),%xmm2
movapd %xmm2,%xmm1
andpd  0x818(%rip),%xmm1
ucomisd 0x820(%rip),%xmm1
jbe    1822 <contract_h_c+0x6b2>
movsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm2
mov    0x58(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm2
mov    0x60(%rsp),%rax
mov    0x8(%rsp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdx
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%rbx
mov    0x8(%rsp),%r13
mov    0x30(%rsp),%r12
jmp    13b9 <contract_h_c+0x249>
mov    %r12,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1060 <get_double_excitation@plt>
mov    %rax,%r13
mov    (%rax),%ebx
mov    0x4(%rax),%eax
mov    0x8(%r13),%r14d
mov    0xc(%r13),%edi
mov    0x6c(%rsp),%edx
imul   %r14d,%edx
mov    (%rsp),%ebp
mov    %ebp,%esi
imul   %eax,%esi
mov    %edi,%ecx
imul   0x48(%rsp),%ecx
add    %edx,%ecx
add    %ecx,%esi
add    %ebx,%esi
mov    %ebp,%edx
imul   %ebx,%edx
add    %eax,%ecx
add    %edx,%ecx
cmp    %eax,%r14d
setg   %r8b
cmp    %edi,%ebx
setg   %dl
or     %r8b,%dl
mov    %ecx,%edx
cmovne %esi,%edx
cmove  %esi,%ecx
mov    %eax,%esi
cmovne %ebx,%esi
cmovne %eax,%ebx
movslq %edx,%rax
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movslq %ecx,%rax
subsd  (%rdx,%rax,8),%xmm0
movapd %xmm0,0x70(%rsp)
mov    %r12,%rdx
mov    0x4(%rsp),%ebp
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x80(%rsp)
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12,%rdx
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movapd 0x70(%rsp),%xmm2
movapd %xmm2,%xmm1
andpd  0x703(%rip),%xmm1
ucomisd 0x70b(%rip),%xmm1
jbe    1937 <contract_h_c+0x7c7>
movsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm2
mov    0x58(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm2
mov    0x60(%rsp),%rax
mov    0x8(%rsp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdx
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%rbx
mov    0x8(%rsp),%r13
jmp    13b9 <contract_h_c+0x249>
mov    0x28(%rsp),%r12
mov    (%rsp),%r9d
mov    0x70(%rsp),%rdi
mov    0x24(%rsp),%ecx
test   %ecx,%ecx
je     198c <contract_h_c+0x81c>
cmp    $0x1,%ecx
mov    0xb8(%rsp),%r10
mov    0xd0(%rsp),%r11
mov    0x8(%rsp),%r13
jne    1993 <contract_h_c+0x823>
xor    %ecx,%ecx
jmp    19dc <contract_h_c+0x86c>
mov    0x8(%rsp),%r13
jmp    19fb <contract_h_c+0x88b>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rax,%rcx,4),%edx
imul   %r9d,%edx
lea    (%r8,%rdx,1),%esi
imul   %ebx,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  (%r12,%rdx,8),%xmm0
mov    0x4(%rax,%rcx,4),%edx
imul   %r9d,%edx
lea    (%r8,%rdx,1),%esi
imul   %ebx,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  (%r12,%rdx,8),%xmm0
add    $0x2,%rcx
cmp    %rcx,%r11
jne    19a0 <contract_h_c+0x830>
test   $0x1,%r10b
je     19fb <contract_h_c+0x88b>
mov    (%rax,%rcx,4),%ecx
imul   %r9d,%ecx
add    %ecx,%r8d
imul   %ebx,%ecx
add    %r8d,%ecx
movslq %ecx,%rcx
addsd  (%r12,%rcx,8),%xmm0
mov    %rax,%rbx
movapd %xmm0,%xmm1
andpd  0x5f6(%rip),%xmm1
ucomisd 0x5fe(%rip),%xmm1
jbe    1a2f <contract_h_c+0x8bf>
movsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    0x30(%rsp),%r12
jmp    1b05 <contract_h_c+0x995>
mov    0x30(%rsp),%r12
jmp    1b21 <contract_h_c+0x9b1>
mov    0x28(%rsp),%rbp
mov    (%rsp),%ebx
mov    0xa0(%rsp),%r8
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
mov    0x70(%rsp),%rdi
je     1a71 <contract_h_c+0x901>
cmp    $0x1,%ecx
mov    0xc8(%rsp),%r9
mov    0x8(%rsp),%r13
mov    0x30(%rsp),%r12
jne    1a7d <contract_h_c+0x90d>
xor    %ecx,%ecx
jmp    1abc <contract_h_c+0x94c>
mov    0x8(%rsp),%r13
mov    0x30(%rsp),%r12
jmp    1adb <contract_h_c+0x96b>
xor    %ecx,%ecx
nop
mov    (%rdi,%rcx,4),%edx
imul   %ebx,%edx
lea    (%r10,%rdx,1),%esi
imul   %r14d,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  0x0(%rbp,%rdx,8),%xmm0
mov    0x4(%rdi,%rcx,4),%edx
imul   %ebx,%edx
lea    (%r10,%rdx,1),%esi
imul   %r14d,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  0x0(%rbp,%rdx,8),%xmm0
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1a80 <contract_h_c+0x910>
test   $0x1,%r8b
je     1adb <contract_h_c+0x96b>
mov    (%rdi,%rcx,4),%ecx
imul   %ebx,%ecx
add    %ecx,%r10d
imul   %r14d,%ecx
add    %r10d,%ecx
movslq %ecx,%rcx
addsd  0x0(%rbp,%rcx,8),%xmm0
mov    %rax,%rbx
movapd %xmm0,%xmm1
andpd  0x516(%rip),%xmm1
ucomisd 0x51e(%rip),%xmm1
jbe    1b21 <contract_h_c+0x9b1>
movsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    0x58(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm0
mov    0x60(%rsp),%rax
addsd  (%rax,%r13,8),%xmm0
movsd  %xmm0,(%rax,%r13,8)
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
jmp    13aa <contract_h_c+0x23a>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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