#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_ss_c(double *h1, double *eri, int norb, int neleca,
                       int nelecb, uint64_t *strs, double *civec, double *hdiag,
                       uint64_t ndet, double *ci1, double *ci2) {
  int *ts = malloc(sizeof(int) * ndet);
#pragma omp parallel
  {
    size_t ip, jp, p, q;
    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];
            double apb = (double)(neleca + nelecb);
            double amb = (double)(neleca - nelecb);
            double prefactor = apb / 2.0 + amb * amb / 4.0;
            int *occsa = compute_occ_list(stria, nset, norb, neleca);
            int *occsb = compute_occ_list(strib, nset, norb, nelecb);
            for (p = 0; p < neleca; ++p) {
              int pa = occsa[p];
              for (q = 0; q < nelecb; ++q) {
                int qb = occsb[q];
                if (pa == qb)
                  prefactor -= 1.0;
              }
            }
            ci2[ip] += prefactor * civec[ip];
            free(occsa);
            free(occsb);
          } 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];
              if (i == b && j == a) {
                ci2[ip] -= sign * civec[jp];
              }
              free(ia);
              free(jb);
            }
          }
        }
      }
    }
  }
  free(ts);
}


x86 assembly (clang, -O0):
<contract_h_c_ss_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
mov    0x30(%rbp),%rax
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,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    12a9 <contract_h_c_ss_c+0x129>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x54(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x54(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   1050 <n_excitations@plt>
mov    %eax,-0x1cc(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   1050 <n_excitations@plt>
mov    -0x1cc(%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    1205 <contract_h_c_ss_c+0x85>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    2225 <contract_h_c_ss_c+0x10a5>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq 0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    220f <contract_h_c_ss_c+0x108f>
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    21f9 <contract_h_c_ss_c+0x1079>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x54(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x54(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x54(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movslq -0x54(%rbp),%rdx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   1050 <n_excitations@plt>
mov    %eax,-0x9c(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   1050 <n_excitations@plt>
mov    %eax,-0xa0(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    15a6 <contract_h_c_ss_c+0x426>
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)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%eax
sub    -0x1c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x1bcb(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movsd  0x1ba7(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x80(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0xc8(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    155a <contract_h_c_ss_c+0x3da>
mov    -0xc0(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xcc(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jae    1544 <contract_h_c_ss_c+0x3c4>
mov    -0xc8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jne    152e <contract_h_c_ss_c+0x3ae>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x1af6(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1533 <contract_h_c_ss_c+0x3b3>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14db <contract_h_c_ss_c+0x35b>
jmp    1549 <contract_h_c_ss_c+0x3c9>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    14ae <contract_h_c_ss_c+0x32e>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
jmp    21f4 <contract_h_c_ss_c+0x1074>
mov    -0x9c(%rbp),%eax
add    -0xa0(%rbp),%eax
cmp    $0x1,%eax
jne    1b36 <contract_h_c_ss_c+0x9b6>
cmpl   $0x0,-0xa0(%rbp)
jne    186d <contract_h_c_ss_c+0x6ed>
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xd8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x80(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0xf0(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0xf8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xe0(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0xdc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    175c <contract_h_c_ss_c+0x5dc>
mov    -0xf0(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x104(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xe0(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xdc(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x104(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0xdc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xe0(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x104(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x108(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x10c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1682 <contract_h_c_ss_c+0x502>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jae    17f4 <contract_h_c_ss_c+0x674>
mov    -0xf8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x110(%rbp)
mov    -0x110(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x110(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0xe0(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xdc(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1764 <contract_h_c_ss_c+0x5e4>
movsd  -0x100(%rbp),%xmm0
ff
movaps 0x181d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x17f1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1850 <contract_h_c_ss_c+0x6d0>
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x100(%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    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
jmp    1b25 <contract_h_c_ss_c+0x9a5>
cmpl   $0x0,-0x9c(%rbp)
jne    1b20 <contract_h_c_ss_c+0x9a0>
mov    -0x88(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x118(%rbp)
mov    -0xd8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%edi
mov    -0x118(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x80(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0x130(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1090 <compute_occ_list@plt>
mov    %rax,-0x138(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x11c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x118(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jae    1a14 <contract_h_c_ss_c+0x894>
mov    -0x138(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x144(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x11c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x118(%rbp),%eax
mov    %eax,-0x148(%rbp)
mov    -0x144(%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    -0x11c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x144(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x148(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    193a <contract_h_c_ss_c+0x7ba>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    1aac <contract_h_c_ss_c+0x92c>
mov    -0x130(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x150(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x11c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x118(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1a1c <contract_h_c_ss_c+0x89c>
movsd  -0x140(%rbp),%xmm0
ff
movaps 0x1565(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1539(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1b08 <contract_h_c_ss_c+0x988>
movsd  -0x128(%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    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0x138(%rbp),%rdi
call   1030 <free@plt>
jmp    1b25 <contract_h_c_ss_c+0x9a5>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
jmp    21ef <contract_h_c_ss_c+0x106f>
mov    -0x9c(%rbp),%eax
add    -0xa0(%rbp),%eax
cmp    $0x2,%eax
jne    21ea <contract_h_c_ss_c+0x106a>
cmpl   $0x0,-0xa0(%rbp)
jne    1d9b <contract_h_c_ss_c+0xc1b>
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   1070 <get_double_excitation@plt>
mov    %rax,-0x170(%rbp)
mov    -0x170(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x158(%rbp)
mov    -0x170(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x170(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x160(%rbp)
mov    -0x170(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x164(%rbp)
mov    -0x160(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x15c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x164(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x158(%rbp),%eax
mov    %eax,-0x184(%rbp)
mov    -0x160(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x158(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x164(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x15c(%rbp),%eax
mov    %eax,-0x188(%rbp)
mov    -0x160(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jg     1c49 <contract_h_c_ss_c+0xac9>
mov    -0x158(%rbp),%eax
cmp    -0x164(%rbp),%eax
jle    1cbe <contract_h_c_ss_c+0xb3e>
mov    -0x10(%rbp),%rax
movslq -0x184(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x188(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x164(%rbp),%edi
mov    -0x158(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x160(%rbp),%edi
mov    -0x15c(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
jmp    1d2e <contract_h_c_ss_c+0xbae>
mov    -0x10(%rbp),%rax
movslq -0x188(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x184(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x164(%rbp),%edi
mov    -0x15c(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x160(%rbp),%edi
mov    -0x158(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
movaps 0x12e3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x12b7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1d8a <contract_h_c_ss_c+0xc0a>
movsd  -0x180(%rbp),%xmm0
ff
mulsd  -0x178(%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    -0x170(%rbp),%rdi
call   1030 <free@plt>
jmp    21e5 <contract_h_c_ss_c+0x1065>
cmpl   $0x0,-0x9c(%rbp)
jne    1ffa <contract_h_c_ss_c+0xe7a>
mov    -0x88(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   1070 <get_double_excitation@plt>
mov    %rax,-0x190(%rbp)
mov    -0x190(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x158(%rbp)
mov    -0x190(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x190(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x160(%rbp)
mov    -0x190(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x164(%rbp)
mov    -0x160(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x15c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x164(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x158(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x160(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x158(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    -0x164(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0x15c(%rbp),%eax
mov    %eax,-0x1a8(%rbp)
mov    -0x160(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jg     1e9c <contract_h_c_ss_c+0xd1c>
mov    -0x158(%rbp),%eax
cmp    -0x164(%rbp),%eax
jle    1f17 <contract_h_c_ss_c+0xd97>
mov    -0x10(%rbp),%rax
movslq -0x1a4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1a8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x164(%rbp),%edi
mov    -0x158(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x160(%rbp),%edi
mov    -0x15c(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
jmp    1f8d <contract_h_c_ss_c+0xe0d>
mov    -0x10(%rbp),%rax
movslq -0x1a8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1a4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x164(%rbp),%edi
mov    -0x15c(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x160(%rbp),%edi
mov    -0x158(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
movaps 0x1084(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1058(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1fe9 <contract_h_c_ss_c+0xe69>
movsd  -0x1a0(%rbp),%xmm0
ff
mulsd  -0x198(%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    -0x190(%rbp),%rdi
call   1030 <free@plt>
jmp    21e0 <contract_h_c_ss_c+0x1060>
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0x1b0(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x54(%rbp),%edx
call   10a0 <get_single_excitation@plt>
mov    %rax,-0x1b8(%rbp)
mov    -0x1b0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x158(%rbp)
mov    -0x1b0(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x160(%rbp)
mov    -0x1b8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x1b8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x164(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x160(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x158(%rbp),%edx
imul   -0x14(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
mov    -0x164(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x15c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x160(%rbp),%edi
mov    -0x158(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x164(%rbp),%edi
mov    -0x15c(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
call   1080 <compute_cre_des_sign@plt>
mulsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
movaps 0xf0f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xee3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    215e <contract_h_c_ss_c+0xfde>
movsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1c0(%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),%eax
cmp    -0x164(%rbp),%eax
jne    21c8 <contract_h_c_ss_c+0x1048>
mov    -0x15c(%rbp),%eax
cmp    -0x160(%rbp),%eax
jne    21c8 <contract_h_c_ss_c+0x1048>
movsd  -0x1c8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1b0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1b8(%rbp),%rdi
call   1030 <free@plt>
jmp    21e5 <contract_h_c_ss_c+0x1065>
jmp    21ea <contract_h_c_ss_c+0x106a>
jmp    21ef <contract_h_c_ss_c+0x106f>
jmp    21f4 <contract_h_c_ss_c+0x1074>
jmp    21f9 <contract_h_c_ss_c+0x1079>
jmp    21fe <contract_h_c_ss_c+0x107e>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12ca <contract_h_c_ss_c+0x14a>
jmp    2214 <contract_h_c_ss_c+0x1094>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12b1 <contract_h_c_ss_c+0x131>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<contract_h_c_ss_c>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,0x40(%rsp)
mov    %r8,0x90(%rsp)
mov    %rcx,0x88(%rsp)
mov    %edx,%ebx
mov    %rsi,0x48(%rsp)
mov    %rdi,0xc0(%rsp)
movslq 0x170(%rsp),%rbp
mov    0x180(%rsp),%rax
mov    %rax,0xd0(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0x108(%rsp)
mov    0x160(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x0(,%rbp,4),%edi
call   1050 <malloc@plt>
mov    %rbp,%r11
mov    %rax,%r12
lea    0x3f(%rbx),%eax
mov    %rbx,%rcx
mov    %rbx,0x50(%rsp)
lea    0x7e(%rbx),%r13d
test   %eax,%eax
cmovns %eax,%r13d
sar    $0x6,%r13d
movl   $0x0,(%r12)
movslq %r13d,%rax
mov    %rax,0xa8(%rsp)
cmp    $0x2,%rbp
mov    %r12,0x30(%rsp)
jb     12b9 <contract_h_c_ss_c+0x149>
mov    0xa8(%rsp),%rcx
mov    0x40(%rsp),%rsi
lea    (%rsi,%rcx,4),%rax
mov    %rax,0x28(%rsp)
lea    (%rcx,%rcx,2),%rax
lea    (%rsi,%rax,4),%rbp
lea    0x0(,%rcx,8),%rax
mov    %rax,0x8(%rsp)
lea    (%rsi,%rcx,8),%rbx
mov    $0x1,%r14d
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    0x40(%rsp),%rsi
mov    %r13d,%edx
mov    %r11,%r15
call   1040 <n_excitations@plt>
mov    %eax,%r12d
mov    %rbp,%rdi
mov    0x28(%rsp),%rsi
mov    %r13d,%edx
call   1040 <n_excitations@plt>
mov    %r15,%r11
add    %r12d,%eax
mov    0x30(%rsp),%r12
mov    %eax,(%r12,%r14,4)
add    $0x1,%r14
mov    0x8(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
cmp    %r14,%r15
jne    1270 <contract_h_c_ss_c+0x100>
mov    %r13d,0x4(%rsp)
test   %r11d,%r11d
mov    0x40(%rsp),%r10
mov    0x90(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x50(%rsp),%rcx
je     1d7f <contract_h_c_ss_c+0xc0f>
mov    0xa8(%rsp),%rax
add    %rax,%rax
mov    %rax,0xe8(%rsp)
mov    %ecx,%r9d
imul   %ecx,%r9d
mov    %r9d,%edi
lea    (%rdx,%rsi,1),%eax
cvtsi2sd %eax,%xmm0
mov    %esi,%eax
sub    %edx,%eax
cvtsi2sd %eax,%xmm1
mulsd  0xceb(%rip),%xmm0
imul   %ecx,%edi
mov    %edi,0x9c(%rsp)
mulsd  %xmm1,%xmm1
mulsd  0xcdd(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0xe0(%rsp)
cmp    $0x2,%edx
mov    $0x1,%eax
mov    $0x1,%ecx
cmovae %edx,%ecx
movslq %ecx,%r8
cmp    $0x2,%esi
cmovae %esi,%eax
movslq %eax,%r15
cmp    $0x2,%r11
mov    $0x1,%esi
cmovae %r11,%rsi
lea    -0x1(%r8),%rdx
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xf0(%rsp)
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xf8(%rsp)
mov    %r8d,%r14d
and    $0x3,%r14d
mov    %r8,%r13
and    $0xfffffffffffffffc,%r13
xor    %r11d,%r11d
mov    %r9d,0x14(%rsp)
mov    %r8,0xb8(%rsp)
mov    %r15,0xa0(%rsp)
mov    %rsi,0x68(%rsp)
mov    %rdx,0xd8(%rsp)
jmp    13cd <contract_h_c_ss_c+0x25d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    %rsi,%r11
je     1d7f <contract_h_c_ss_c+0xc0f>
mov    0xe8(%rsp),%rax
imul   %r11,%rax
lea    (%r10,%rax,4),%rdi
mov    0xa8(%rsp),%rax
lea    (%rdi,%rax,4),%rax
mov    %rax,0x60(%rsp)
xor    %ebx,%ebx
mov    %rdi,0x20(%rsp)
mov    %r11,0x8(%rsp)
jmp    145b <contract_h_c_ss_c+0x2eb>
nopl   0x0(%rax)
mov    0x58(%rsp),%rax
mov    0x8(%rsp),%rbp
mulsd  (%rax,%rbp,8),%xmm1
mov    0xd0(%rsp),%rax
addsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
mov    %r15,%rdi
mov    %r10,%r12
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12,%r10
mov    %rbp,%r11
mov    0x30(%rsp),%r12
mov    0x68(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rbx
add    $0x1,%rbx
cmp    %rsi,%rbx
je     13c0 <contract_h_c_ss_c+0x250>
mov    (%r12,%r11,4),%eax
sub    (%r12,%rbx,4),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    $0x2,%ecx
ja     144e <contract_h_c_ss_c+0x2de>
mov    0xe8(%rsp),%rax
imul   %rbx,%rax
lea    (%r10,%rax,4),%r15
mov    0xa8(%rsp),%rax
lea    (%r15,%rax,4),%rbp
mov    %r15,%rsi
mov    0x4(%rsp),%r12d
mov    %r12d,%edx
mov    %rbx,0x28(%rsp)
call   1040 <n_excitations@plt>
mov    %rax,0x70(%rsp)
mov    0x60(%rsp),%rdi
mov    %rbp,0x18(%rsp)
mov    %rbp,%rsi
mov    %r12d,%edx
call   1040 <n_excitations@plt>
mov    0x28(%rsp),%rbx
mov    0x8(%rsp),%r11
cmp    %rbx,%r11
jne    1640 <contract_h_c_ss_c+0x4d0>
mov    0x108(%rsp),%rax
movsd  (%rax,%r11,8),%xmm0
mov    0x58(%rsp),%rax
mulsd  (%rax,%r11,8),%xmm0
mov    0x80(%rsp),%rax
addsd  (%rax,%r11,8),%xmm0
movsd  %xmm0,(%rax,%r11,8)
mov    0x20(%rsp),%rdi
mov    %r12d,%esi
mov    0x50(%rsp),%rbx
mov    %ebx,%edx
mov    0x88(%rsp),%rbp
mov    %ebp,%ecx
call   1080 <compute_occ_list@plt>
mov    %rax,%r15
mov    0x60(%rsp),%rdi
mov    %r12d,%esi
mov    %ebx,%edx
mov    0x90(%rsp),%rbx
mov    %ebx,%ecx
call   1080 <compute_occ_list@plt>
mov    %rbx,%r11
mov    %rax,%rbx
movsd  0xe0(%rsp),%xmm1
test   %ebp,%ebp
mov    0x40(%rsp),%r10
mov    0xa0(%rsp),%rbp
mov    0xd8(%rsp),%r8
movsd  0xab6(%rip),%xmm2
je     1400 <contract_h_c_ss_c+0x290>
xor    %eax,%eax
movsd  0xe0(%rsp),%xmm0
jmp    1595 <contract_h_c_ss_c+0x425>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm0,%xmm1
add    $0x1,%rax
movapd %xmm1,%xmm0
cmp    %rbp,%rax
je     1400 <contract_h_c_ss_c+0x290>
test   %r11d,%r11d
je     1580 <contract_h_c_ss_c+0x410>
mov    (%r15,%rax,4),%ecx
xor    %edx,%edx
cmp    $0x3,%r8
jae    15e9 <contract_h_c_ss_c+0x479>
movapd %xmm0,%xmm1
test   %r14,%r14
je     1584 <contract_h_c_ss_c+0x414>
lea    (%rbx,%rdx,4),%rdx
xor    %esi,%esi
movapd %xmm0,%xmm1
jmp    15cd <contract_h_c_ss_c+0x45d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
movapd %xmm1,%xmm0
cmp    %rsi,%r14
je     1584 <contract_h_c_ss_c+0x414>
addsd  %xmm2,%xmm1
cmp    (%rdx,%rsi,4),%ecx
je     15c0 <contract_h_c_ss_c+0x450>
movapd %xmm0,%xmm1
jmp    15c0 <contract_h_c_ss_c+0x450>
nopl   0x0(%rax)
add    $0x4,%rdx
cmp    %rdx,%r13
je     15a6 <contract_h_c_ss_c+0x436>
cmp    (%rbx,%rdx,4),%ecx
je     1610 <contract_h_c_ss_c+0x4a0>
cmp    0x4(%rbx,%rdx,4),%ecx
je     161a <contract_h_c_ss_c+0x4aa>
cmp    0x8(%rbx,%rdx,4),%ecx
je     1624 <contract_h_c_ss_c+0x4b4>
cmp    0xc(%rbx,%rdx,4),%ecx
jne    15e0 <contract_h_c_ss_c+0x470>
jmp    162e <contract_h_c_ss_c+0x4be>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  %xmm2,%xmm0
cmp    0x4(%rbx,%rdx,4),%ecx
jne    15f4 <contract_h_c_ss_c+0x484>
addsd  %xmm2,%xmm0
cmp    0x8(%rbx,%rdx,4),%ecx
jne    15fa <contract_h_c_ss_c+0x48a>
addsd  %xmm2,%xmm0
cmp    0xc(%rbx,%rdx,4),%ecx
jne    15e0 <contract_h_c_ss_c+0x470>
addsd  %xmm2,%xmm0
jmp    15e0 <contract_h_c_ss_c+0x470>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15,%r10
mov    0x18(%rsp),%r12
mov    0x70(%rsp),%rdi
lea    (%rax,%rdi,1),%ecx
cmp    $0x2,%ecx
je     177f <contract_h_c_ss_c+0x60f>
cmp    $0x1,%ecx
jne    18d9 <contract_h_c_ss_c+0x769>
test   %eax,%eax
je     18f2 <contract_h_c_ss_c+0x782>
mov    %r12,%rsi
test   %edi,%edi
mov    0x30(%rsp),%r12
jne    1d5e <contract_h_c_ss_c+0xbee>
mov    0x60(%rsp),%rbp
mov    %rbp,%rdi
mov    0x4(%rsp),%ebx
mov    %ebx,%edx
call   1090 <get_single_excitation@plt>
mov    (%rax),%esi
mov    %rsi,0x38(%rsp)
mov    %rax,0xc8(%rsp)
mov    0x4(%rax),%r12d
mov    %r12d,%edi
mov    %rbp,%rdx
mov    %ebx,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x70(%rsp)
mov    0x20(%rsp),%rdi
mov    %ebx,%esi
mov    0x50(%rsp),%r15
mov    %r15d,%edx
mov    0x88(%rsp),%rcx
call   1080 <compute_occ_list@plt>
mov    %rax,0x18(%rsp)
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r15d,%edx
mov    0x90(%rsp),%rbx
mov    %ebx,%ecx
call   1080 <compute_occ_list@plt>
mov    %r12,%r11
mov    0x38(%rsp),%r12
mov    %r15,%r8
mov    %rax,%r15
imul   %r8d,%r11d
lea    (%r11,%r12,1),%r10d
movslq %r10d,%rcx
mov    0xc0(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm0
test   %ebx,%ebx
je     1c3e <contract_h_c_ss_c+0xace>
mov    0x14(%rsp),%eax
imul   %eax,%r12d
xor    %ecx,%ecx
mov    0x48(%rsp),%rbp
mov    0xb8(%rsp),%rbx
mov    0xa0(%rsp),%r9
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rcx,4),%edx
mov    %eax,%esi
imul   %edx,%esi
lea    (%r10,%rsi,1),%edi
imul   %r8d,%esi
add    %esi,%edi
add    %r11d,%esi
add    %r12d,%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,%rbx
jne    1740 <contract_h_c_ss_c+0x5d0>
jmp    1c4f <contract_h_c_ss_c+0xadf>
test   %eax,%eax
mov    0x14(%rsp),%eax
je     1a0c <contract_h_c_ss_c+0x89c>
test   %edi,%edi
mov    0x4(%rsp),%edx
je     1a9b <contract_h_c_ss_c+0x92b>
mov    0x20(%rsp),%rdi
mov    %r10,%rsi
mov    %edx,%ebp
call   1090 <get_single_excitation@plt>
mov    %rax,%rbx
mov    0x60(%rsp),%r15
mov    %r15,%rdi
mov    %r12,%rsi
mov    %ebp,%edx
call   1090 <get_single_excitation@plt>
mov    (%rbx),%esi
mov    %rbx,0x18(%rsp)
mov    0x4(%rbx),%edi
mov    (%rax),%r12d
mov    %rax,0x70(%rsp)
mov    0x4(%rax),%ebx
mov    %edi,%eax
mov    0x50(%rsp),%rcx
imul   %ecx,%eax
add    %esi,%eax
imul   %ecx,%eax
add    %ebx,%eax
imul   %ecx,%eax
add    %r12d,%eax
cltq
mov    0x48(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movapd %xmm0,0x110(%rsp)
mov    %edi,0xb0(%rsp)
mov    %esi,0x38(%rsp)
mov    0x20(%rsp),%rdx
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x100(%rsp)
mov    %ebx,%edi
mov    %r12d,0xb4(%rsp)
mov    %r12d,%esi
mov    %r15,%rdx
mov    %ebp,%ecx
call   1070 <compute_cre_des_sign@plt>
movapd 0x110(%rsp),%xmm2
mulsd  0x100(%rsp),%xmm0
movapd %xmm2,%xmm1
andpd  0x7cf(%rip),%xmm1
ucomisd 0x7b7(%rip),%xmm1
mov    0x8(%rsp),%rdx
mov    0x28(%rsp),%rsi
jbe    1885 <contract_h_c_ss_c+0x715>
mulsd  %xmm0,%xmm2
mov    0x58(%rsp),%rax
mulsd  (%rax,%rsi,8),%xmm2
mov    0x80(%rsp),%rax
addsd  (%rax,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rdx,8)
cmp    %ebx,0x38(%rsp)
jne    18bb <contract_h_c_ss_c+0x74b>
mov    0xb0(%rsp),%eax
cmp    %eax,0xb4(%rsp)
jne    18bb <contract_h_c_ss_c+0x74b>
mov    0xd0(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm1
mov    0x58(%rsp),%rcx
mulsd  (%rcx,%rsi,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rbx
mov    0x8(%rsp),%r11
mov    0x40(%rsp),%r10
mov    0x30(%rsp),%r12
mov    0x68(%rsp),%rsi
mov    0x20(%rsp),%rdi
jmp    144e <contract_h_c_ss_c+0x2de>
mov    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    %r10,%rsi
mov    0x4(%rsp),%ebx
mov    %ebx,%edx
call   1090 <get_single_excitation@plt>
mov    (%rax),%r12d
mov    %rax,0xc8(%rsp)
mov    0x4(%rax),%edi
mov    %rdi,0x38(%rsp)
mov    %r12d,%esi
mov    %rbp,%rdx
mov    %ebx,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x70(%rsp)
mov    %rbp,%rdi
mov    %ebx,%esi
mov    0x50(%rsp),%r15
mov    %r15d,%edx
mov    0x88(%rsp),%rbp
mov    %ebp,%ecx
call   1080 <compute_occ_list@plt>
mov    %rax,0x18(%rsp)
mov    0x60(%rsp),%rdi
mov    %ebx,%esi
mov    %r15d,%edx
mov    0x90(%rsp),%rcx
call   1080 <compute_occ_list@plt>
mov    0x38(%rsp),%r8
mov    %r15,%r9
mov    %rax,%r15
imul   %r9d,%r8d
lea    (%r8,%r12,1),%r10d
movslq %r10d,%rcx
mov    0xc0(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
test   %ebp,%ebp
je     1bb0 <contract_h_c_ss_c+0xa40>
mov    %r12,%rsi
mov    0x14(%rsp),%eax
imul   %eax,%esi
xor    %ecx,%ecx
mov    0x48(%rsp),%rbp
mov    0xa0(%rsp),%r11
mov    0x18(%rsp),%rdi
mov    %rsi,%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%rcx,4),%edx
mov    %eax,%esi
imul   %edx,%esi
lea    (%r10,%rsi,1),%ebx
imul   %r9d,%esi
add    %esi,%ebx
add    %r8d,%esi
add    %r12d,%esi
add    %edx,%esi
movslq %ebx,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm1
movslq %esi,%rdx
subsd  0x0(%rbp,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r11
jne    19c0 <contract_h_c_ss_c+0x850>
cmpl   $0x0,0x90(%rsp)
jne    1bcc <contract_h_c_ss_c+0xa5c>
jmp    1cfb <contract_h_c_ss_c+0xb8b>
mov    0x20(%rsp),%r12
mov    %r12,%rdi
mov    %r10,%rsi
mov    0x4(%rsp),%edx
mov    %eax,%ebx
call   1060 <get_double_excitation@plt>
mov    %rax,%r15
mov    (%rax),%ebp
mov    0x4(%rax),%eax
mov    0x8(%r15),%ecx
mov    0xc(%r15),%edi
mov    0x9c(%rsp),%edx
imul   %ecx,%edx
mov    %ecx,%r8d
mov    %ecx,0x18(%rsp)
mov    %ebx,%esi
imul   %eax,%esi
mov    %edi,%ecx
imul   0x50(%rsp),%ecx
add    %edx,%ecx
add    %ecx,%esi
add    %ebp,%esi
mov    %ebx,%edx
imul   %ebp,%edx
add    %eax,%ecx
add    %edx,%ecx
cmp    %eax,%r8d
setg   %dl
cmp    %edi,%ebp
setg   %bl
or     %dl,%bl
mov    %ecx,%edx
cmovne %esi,%edx
cmove  %esi,%ecx
mov    %eax,%esi
cmovne %ebp,%esi
cmovne %eax,%ebp
movslq %edx,%rax
mov    0x48(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movslq %ecx,%rax
subsd  (%rdx,%rax,8),%xmm0
movapd %xmm0,0x70(%rsp)
jmp    1b25 <contract_h_c_ss_c+0x9b5>
mov    0x60(%rsp),%rdi
mov    %r12,%rsi
call   1060 <get_double_excitation@plt>
mov    %rax,%r15
mov    (%rax),%ebp
mov    0x4(%rax),%eax
mov    0x8(%r15),%ecx
mov    0xc(%r15),%edi
mov    0x9c(%rsp),%edx
imul   %ecx,%edx
mov    %ecx,%r8d
mov    %ecx,0x18(%rsp)
mov    0x14(%rsp),%ebx
mov    %ebx,%esi
imul   %eax,%esi
mov    %edi,%ecx
imul   0x50(%rsp),%ecx
add    %edx,%ecx
add    %ecx,%esi
add    %ebp,%esi
mov    %ebx,%edx
imul   %ebp,%edx
add    %eax,%ecx
add    %edx,%ecx
cmp    %eax,%r8d
setg   %dl
cmp    %edi,%ebp
setg   %bl
or     %dl,%bl
mov    %ecx,%edx
cmovne %esi,%edx
cmove  %esi,%ecx
mov    %eax,%esi
cmovne %ebp,%esi
cmovne %eax,%ebp
movslq %edx,%rax
mov    0x48(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movslq %ecx,%rax
subsd  (%rdx,%rax,8),%xmm0
movapd %xmm0,0x70(%rsp)
mov    0x60(%rsp),%r12
mov    %r12,%rdx
mov    0x4(%rsp),%ebx
mov    %ebx,%ecx
call   1070 <compute_cre_des_sign@plt>
movsd  %xmm0,0x38(%rsp)
mov    0x18(%rsp),%edi
mov    %ebp,%esi
mov    %r12,%rdx
mov    %ebx,%ecx
call   1070 <compute_cre_des_sign@plt>
movapd 0x70(%rsp),%xmm2
movapd %xmm2,%xmm1
andpd  0x4c5(%rip),%xmm1
ucomisd 0x4ad(%rip),%xmm1
jbe    1b99 <contract_h_c_ss_c+0xa29>
movsd  0x38(%rsp),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm2
mov    0x58(%rsp),%rax
mov    0x28(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x80(%rsp),%rax
mov    0x8(%rsp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%r10
mov    0x30(%rsp),%r12
jmp    1d70 <contract_h_c_ss_c+0xc00>
mov    0x48(%rsp),%rbp
mov    0x14(%rsp),%eax
mov    0x18(%rsp),%rdi
cmpl   $0x0,0x90(%rsp)
je     1cfb <contract_h_c_ss_c+0xb8b>
cmpq   $0x0,0xd8(%rsp)
mov    0xf8(%rsp),%rbx
je     1c75 <contract_h_c_ss_c+0xb05>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rcx,4),%edx
imul   %eax,%edx
lea    (%r10,%rdx,1),%esi
imul   %r9d,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  0x0(%rbp,%rdx,8),%xmm0
mov    0x4(%r15,%rcx,4),%edx
imul   %eax,%edx
lea    (%r10,%rdx,1),%esi
imul   %r9d,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  0x0(%rbp,%rdx,8),%xmm0
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1bf0 <contract_h_c_ss_c+0xa80>
testb  $0x1,0xb8(%rsp)
01
je     1cfb <contract_h_c_ss_c+0xb8b>
jmp    1c81 <contract_h_c_ss_c+0xb11>
mov    0x48(%rsp),%rbp
mov    0xa0(%rsp),%r9
mov    0x14(%rsp),%eax
mov    0x88(%rsp),%rcx
test   %ecx,%ecx
mov    0x18(%rsp),%rdi
je     1cfb <contract_h_c_ss_c+0xb8b>
cmp    $0x1,%ecx
mov    0xf0(%rsp),%rbx
jne    1c91 <contract_h_c_ss_c+0xb21>
xor    %ecx,%ecx
jmp    1cdc <contract_h_c_ss_c+0xb6c>
xor    %ecx,%ecx
testb  $0x1,0xb8(%rsp)
01
je     1cfb <contract_h_c_ss_c+0xb8b>
mov    (%r15,%rcx,4),%ecx
imul   %eax,%ecx
add    %ecx,%r10d
imul   %r9d,%ecx
jmp    1cef <contract_h_c_ss_c+0xb7f>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdi,%rcx,4),%edx
imul   %eax,%edx
lea    (%r10,%rdx,1),%esi
imul   %r8d,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  0x0(%rbp,%rdx,8),%xmm0
mov    0x4(%rdi,%rcx,4),%edx
imul   %eax,%edx
lea    (%r10,%rdx,1),%esi
imul   %r8d,%edx
add    %esi,%edx
movslq %edx,%rdx
addsd  0x0(%rbp,%rdx,8),%xmm0
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1ca0 <contract_h_c_ss_c+0xb30>
test   $0x1,%r9b
je     1cfb <contract_h_c_ss_c+0xb8b>
mov    (%rdi,%rcx,4),%ecx
imul   %eax,%ecx
add    %ecx,%r10d
imul   %r8d,%ecx
add    %r10d,%ecx
movslq %ecx,%rax
addsd  0x0(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
andpd  0x319(%rip),%xmm1
ucomisd 0x301(%rip),%xmm1
jbe    1d4c <contract_h_c_ss_c+0xbdc>
movsd  0x70(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    0x30(%rsp),%r12
mov    0x8(%rsp),%rcx
mov    0x58(%rsp),%rax
mov    0x28(%rsp),%rdx
mulsd  (%rax,%rdx,8),%xmm0
mov    0x80(%rsp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d51 <contract_h_c_ss_c+0xbe1>
mov    0x30(%rsp),%r12
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0xc8(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%r10
mov    0x68(%rsp),%rsi
mov    0x8(%rsp),%r11
jmp    1444 <contract_h_c_ss_c+0x2d4>
mov    %r12,%rdi
add    $0x128,%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_ss_c(double* %0, double* %1, i32 %2, i32 %3, i32 %4, i32* %5, double* %6, double* %7, i32 %8, double* %9, double* %10) {
%12 = alloca double*
%13 = alloca double*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32*
%18 = alloca double*
%19 = alloca double*
%20 = alloca i32
%21 = alloca double*
%22 = alloca double*
%23 = alloca i32*
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%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 double
%41 = alloca double
%42 = alloca i32*
%43 = alloca i32*
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32*
%47 = alloca i32
%48 = alloca i32
%49 = alloca double
%50 = alloca i32*
%51 = alloca i32*
%52 = alloca double
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca double
%61 = alloca i32*
%62 = alloca i32*
%63 = alloca double
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca i32*
%74 = alloca double
%75 = alloca double
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32*
%79 = alloca double
%80 = alloca double
%81 = alloca i32
%82 = alloca i32
%83 = alloca i32*
%84 = alloca i32*
%85 = alloca double
%86 = alloca double
store double* %0, double** %12
store double* %1, double** %13
store i32 %2, i32* %14
store i32 %3, i32* %15
store i32 %4, i32* %16
store i32* %5, i32** %17
store double* %6, double** %18
store double* %7, double** %19
store i32 %8, i32* %20
store double* %9, double** %21
store double* %10, double** %22
%87 = load i32, i32* %20
%88 = sext i32 %87 to i64
%89 = mul i64 4, %88
%90 = trunc i64 %89 to i32
%91 = call i32* @malloc(i32 %90)
store i32* %91, i32** %23
%92 = load i32, i32* %14
%93 = add nsw i32 %92, 63
%94 = sdiv i32 %93, 64
store i32 %94, i32* %28
%95 = load i32*, i32** %23
%96 = getelementptr inbounds i32, i32* %95, i64 0
store i32 0, i32* %96
%97 = load i32*, i32** %17
store i32* %97, i32** %29
%98 = load i32*, i32** %17
%99 = load i32, i32* %28
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %98, i64 %100
store i32* %101, i32** %30
store i64 1, i64* %24
br label %102
102: ; preds = %137, %11
%103 = load i64, i64* %24
%104 = load i32, i32* %20
%105 = sext i32 %104 to i64
%106 = icmp ult i64 %103, %105
br i1 %106, label %107, label %140
107: ; preds = %102
%108 = load i32*, i32** %17
%109 = load i64, i64* %24
%110 = mul i64 %109, 2
%111 = load i32, i32* %28
%112 = sext i32 %111 to i64
%113 = mul i64 %110, %112
%114 = getelementptr inbounds i32, i32* %108, i64 %113
store i32* %114, i32** %31
%115 = load i32*, i32** %17
%116 = load i64, i64* %24
%117 = mul i64 %116, 2
%118 = load i32, i32* %28
%119 = sext i32 %118 to i64
%120 = mul i64 %117, %119
%121 = getelementptr inbounds i32, i32* %115, i64 %120
%122 = load i32, i32* %28
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32, i32* %121, i64 %123
store i32* %124, i32** %32
%125 = load i32*, i32** %31
%126 = load i32*, i32** %29
%127 = load i32, i32* %28
%128 = call i32 @n_excitations(i32* %125, i32* %126, i32 %127)
%129 = load i32*, i32** %32
%130 = load i32*, i32** %30
%131 = load i32, i32* %28
%132 = call i32 @n_excitations(i32* %129, i32* %130, i32 %131)
%133 = add nsw i32 %128, %132
%134 = load i32*, i32** %23
%135 = load i64, i64* %24
%136 = getelementptr inbounds i32, i32* %134, i64 %135
store i32 %133, i32* %136
br label %137
137: ; preds = %107
%138 = load i64, i64* %24
%139 = add i64 %138, 1
store i64 %139, i64* %24
br label %102
140: ; preds = %102
store i64 0, i64* %24
br label %141
141: ; preds = %1013, %140
%142 = load i64, i64* %24
%143 = load i32, i32* %20
%144 = sext i32 %143 to i64
%145 = icmp ult i64 %142, %144
br i1 %145, label %146, label %1016
146: ; preds = %141
store i64 0, i64* %25
br label %147
147: ; preds = %1009, %146
%148 = load i64, i64* %25
%149 = load i32, i32* %20
%150 = sext i32 %149 to i64
%151 = icmp ult i64 %148, %150
br i1 %151, label %152, label %1012
152: ; preds = %147
%153 = load i32*, i32** %23
%154 = load i64, i64* %24
%155 = getelementptr inbounds i32, i32* %153, i64 %154
%156 = load i32, i32* %155
%157 = load i32*, i32** %23
%158 = load i64, i64* %25
%159 = getelementptr inbounds i32, i32* %157, i64 %158
%160 = load i32, i32* %159
%161 = sub nsw i32 %156, %160
%162 = call i32 @abs(i32 %161)
%163 = icmp slt i32 %162, 3
br i1 %163, label %164, label %1008
164: ; preds = %152
%165 = load i32*, i32** %17
%166 = load i64, i64* %24
%167 = mul i64 %166, 2
%168 = load i32, i32* %28
%169 = sext i32 %168 to i64
%170 = mul i64 %167, %169
%171 = getelementptr inbounds i32, i32* %165, i64 %170
store i32* %171, i32** %33
%172 = load i32*, i32** %17
%173 = load i64, i64* %24
%174 = mul i64 %173, 2
%175 = load i32, i32* %28
%176 = sext i32 %175 to i64
%177 = mul i64 %174, %176
%178 = getelementptr inbounds i32, i32* %172, i64 %177
%179 = load i32, i32* %28
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %178, i64 %180
store i32* %181, i32** %34
%182 = load i32*, i32** %17
%183 = load i64, i64* %25
%184 = mul i64 %183, 2
%185 = load i32, i32* %28
%186 = sext i32 %185 to i64
%187 = mul i64 %184, %186
%188 = getelementptr inbounds i32, i32* %182, i64 %187
store i32* %188, i32** %35
%189 = load i32*, i32** %17
%190 = load i64, i64* %25
%191 = mul i64 %190, 2
%192 = load i32, i32* %28
%193 = sext i32 %192 to i64
%194 = mul i64 %191, %193
%195 = getelementptr inbounds i32, i32* %189, i64 %194
%196 = load i32, i32* %28
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
store i32* %198, i32** %36
%199 = load i32*, i32** %33
%200 = load i32*, i32** %35
%201 = load i32, i32* %28
%202 = call i32 @n_excitations(i32* %199, i32* %200, i32 %201)
store i32 %202, i32* %37
%203 = load i32*, i32** %34
%204 = load i32*, i32** %36
%205 = load i32, i32* %28
%206 = call i32 @n_excitations(i32* %203, i32* %204, i32 %205)
store i32 %206, i32* %38
%207 = load i64, i64* %24
%208 = load i64, i64* %25
%209 = icmp eq i64 %207, %208
br i1 %209, label %210, label %298
210: ; preds = %164
%211 = load double*, double** %19
%212 = load i64, i64* %24
%213 = getelementptr inbounds double, double* %211, i64 %212
%214 = load double, double* %213
%215 = load double*, double** %18
%216 = load i64, i64* %24
%217 = getelementptr inbounds double, double* %215, i64 %216
%218 = load double, double* %217
%219 = load double*, double** %21
%220 = load i64, i64* %24
%221 = getelementptr inbounds double, double* %219, i64 %220
%222 = load double, double* %221
%223 = call double @llvm.fmuladd.f64(double %214, double %218, double %222)
store double %223, double* %221
%224 = load i32, i32* %15
%225 = load i32, i32* %16
%226 = add nsw i32 %224, %225
%227 = sitofp i32 %226 to double
store double %227, double* %39
%228 = load i32, i32* %15
%229 = load i32, i32* %16
%230 = sub nsw i32 %228, %229
%231 = sitofp i32 %230 to double
store double %231, double* %40
%232 = load double, double* %39
%233 = fdiv double %232, 2.000000e+00
%234 = load double, double* %40
%235 = load double, double* %40
%236 = fmul double %234, %235
%237 = fdiv double %236, 4.000000e+00
%238 = fadd double %233, %237
store double %238, double* %41
%239 = load i32*, i32** %33
%240 = load i32, i32* %28
%241 = load i32, i32* %14
%242 = load i32, i32* %15
%243 = call i32* @compute_occ_list(i32* %239, i32 %240, i32 %241, i32 %242)
store i32* %243, i32** %42
%244 = load i32*, i32** %34
%245 = load i32, i32* %28
%246 = load i32, i32* %14
%247 = load i32, i32* %16
%248 = call i32* @compute_occ_list(i32* %244, i32 %245, i32 %246, i32 %247)
store i32* %248, i32** %43
store i64 0, i64* %26
br label %249
249: ; preds = %280, %210
%250 = load i64, i64* %26
%251 = load i32, i32* %15
%252 = sext i32 %251 to i64
%253 = icmp ult i64 %250, %252
br i1 %253, label %254, label %283
254: ; preds = %249
%255 = load i32*, i32** %42
%256 = load i64, i64* %26
%257 = getelementptr inbounds i32, i32* %255, i64 %256
%258 = load i32, i32* %257
store i32 %258, i32* %44
store i64 0, i64* %27
br label %259
259: ; preds = %276, %254
%260 = load i64, i64* %27
%261 = load i32, i32* %16
%262 = sext i32 %261 to i64
%263 = icmp ult i64 %260, %262
br i1 %263, label %264, label %279
264: ; preds = %259
%265 = load i32*, i32** %43
%266 = load i64, i64* %27
%267 = getelementptr inbounds i32, i32* %265, i64 %266
%268 = load i32, i32* %267
store i32 %268, i32* %45
%269 = load i32, i32* %44
%270 = load i32, i32* %45
%271 = icmp eq i32 %269, %270
br i1 %271, label %272, label %275
272: ; preds = %264
%273 = load double, double* %41
%274 = fsub double %273, 1.000000e+00
store double %274, double* %41
br label %275
275: ; preds = %272, %264
br label %276
276: ; preds = %275
%277 = load i64, i64* %27
%278 = add i64 %277, 1
store i64 %278, i64* %27
br label %259
279: ; preds = %259
br label %280
280: ; preds = %279
%281 = load i64, i64* %26
%282 = add i64 %281, 1
store i64 %282, i64* %26
br label %249
283: ; preds = %249
%284 = load double, double* %41
%285 = load double*, double** %18
%286 = load i64, i64* %24
%287 = getelementptr inbounds double, double* %285, i64 %286
%288 = load double, double* %287
%289 = load double*, double** %22
%290 = load i64, i64* %24
%291 = getelementptr inbounds double, double* %289, i64 %290
%292 = load double, double* %291
%293 = call double @llvm.fmuladd.f64(double %284, double %288, double %292)
store double %293, double* %291
%294 = load i32*, i32** %42
%295 = call i32 @free(i32* %294)
%296 = load i32*, i32** %43
%297 = call i32 @free(i32* %296)
br label %1007
298: ; preds = %164
%299 = load i32, i32* %37
%300 = load i32, i32* %38
%301 = add nsw i32 %299, %300
%302 = icmp eq i32 %301, 1
br i1 %302, label %303, label %635
303: ; preds = %298
%304 = load i32, i32* %38
%305 = icmp eq i32 %304, 0
br i1 %305, label %306, label %467
306: ; preds = %303
%307 = load i32*, i32** %33
%308 = load i32*, i32** %35
%309 = load i32, i32* %28
%310 = call i32* @get_single_excitation(i32* %307, i32* %308, i32 %309)
store i32* %310, i32** %46
%311 = load i32*, i32** %46
%312 = getelementptr inbounds i32, i32* %311, i64 0
%313 = load i32, i32* %312
store i32 %313, i32* %47
%314 = load i32*, i32** %46
%315 = getelementptr inbounds i32, i32* %314, i64 1
%316 = load i32, i32* %315
store i32 %316, i32* %48
%317 = load i32, i32* %48
%318 = load i32, i32* %47
%319 = load i32*, i32** %33
%320 = load i32, i32* %28
%321 = call double @compute_cre_des_sign(i32 %317, i32 %318, i32* %319, i32 %320)
store double %321, double* %49
%322 = load i32*, i32** %33
%323 = load i32, i32* %28
%324 = load i32, i32* %14
%325 = load i32, i32* %15
%326 = call i32* @compute_occ_list(i32* %322, i32 %323, i32 %324, i32 %325)
store i32* %326, i32** %50
%327 = load i32*, i32** %34
%328 = load i32, i32* %28
%329 = load i32, i32* %14
%330 = load i32, i32* %16
%331 = call i32* @compute_occ_list(i32* %327, i32 %328, i32 %329, i32 %330)
store i32* %331, i32** %51
%332 = load double*, double** %12
%333 = load i32, i32* %48
%334 = load i32, i32* %14
%335 = mul nsw i32 %333, %334
%336 = load i32, i32* %47
%337 = add nsw i32 %335, %336
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds double, double* %332, i64 %338
%340 = load double, double* %339
store double %340, double* %52
store i64 0, i64* %26
br label %341
341: ; preds = %402, %306
%342 = load i64, i64* %26
%343 = load i32, i32* %15
%344 = sext i32 %343 to i64
%345 = icmp ult i64 %342, %344
br i1 %345, label %346, label %405
346: ; preds = %341
%347 = load i32*, i32** %50
%348 = load i64, i64* %26
%349 = getelementptr inbounds i32, i32* %347, i64 %348
%350 = load i32, i32* %349
store i32 %350, i32* %53
%351 = load i32, i32* %53
%352 = load i32, i32* %14
%353 = mul nsw i32 %351, %352
%354 = load i32, i32* %14
%355 = mul nsw i32 %353, %354
%356 = load i32, i32* %14
%357 = mul nsw i32 %355, %356
%358 = load i32, i32* %53
%359 = load i32, i32* %14
%360 = mul nsw i32 %358, %359
%361 = load i32, i32* %14
%362 = mul nsw i32 %360, %361
%363 = add nsw i32 %357, %362
%364 = load i32, i32* %48
%365 = load i32, i32* %14
%366 = mul nsw i32 %364, %365
%367 = add nsw i32 %363, %366
%368 = load i32, i32* %47
%369 = add nsw i32 %367, %368
store i32 %369, i32* %54
%370 = load i32, i32* %53
%371 = load i32, i32* %14
%372 = mul nsw i32 %370, %371
%373 = load i32, i32* %14
%374 = mul nsw i32 %372, %373
%375 = load i32, i32* %14
%376 = mul nsw i32 %374, %375
%377 = load i32, i32* %47
%378 = load i32, i32* %14
%379 = mul nsw i32 %377, %378
%380 = load i32, i32* %14
%381 = mul nsw i32 %379, %380
%382 = add nsw i32 %376, %381
%383 = load i32, i32* %48
%384 = load i32, i32* %14
%385 = mul nsw i32 %383, %384
%386 = add nsw i32 %382, %385
%387 = load i32, i32* %53
%388 = add nsw i32 %386, %387
store i32 %388, i32* %55
%389 = load double*, double** %13
%390 = load i32, i32* %54
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double, double* %389, i64 %391
%393 = load double, double* %392
%394 = load double*, double** %13
%395 = load i32, i32* %55
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %394, i64 %396
%398 = load double, double* %397
%399 = fsub double %393, %398
%400 = load double, double* %52
%401 = fadd double %400, %399
store double %401, double* %52
br label %402
402: ; preds = %346
%403 = load i64, i64* %26
%404 = add i64 %403, 1
store i64 %404, i64* %26
br label %341
405: ; preds = %341
store i64 0, i64* %26
br label %406
406: ; preds = %442, %405
%407 = load i64, i64* %26
%408 = load i32, i32* %16
%409 = sext i32 %408 to i64
%410 = icmp ult i64 %407, %409
br i1 %410, label %411, label %445
411: ; preds = %406
%412 = load i32*, i32** %51
%413 = load i64, i64* %26
%414 = getelementptr inbounds i32, i32* %412, i64 %413
%415 = load i32, i32* %414
store i32 %415, i32* %56
%416 = load i32, i32* %56
%417 = load i32, i32* %14
%418 = mul nsw i32 %416, %417
%419 = load i32, i32* %14
%420 = mul nsw i32 %418, %419
%421 = load i32, i32* %14
%422 = mul nsw i32 %420, %421
%423 = load i32, i32* %56
%424 = load i32, i32* %14
%425 = mul nsw i32 %423, %424
%426 = load i32, i32* %14
%427 = mul nsw i32 %425, %426
%428 = add nsw i32 %422, %427
%429 = load i32, i32* %48
%430 = load i32, i32* %14
%431 = mul nsw i32 %429, %430
%432 = add nsw i32 %428, %431
%433 = load i32, i32* %47
%434 = add nsw i32 %432, %433
store i32 %434, i32* %57
%435 = load double*, double** %13
%436 = load i32, i32* %57
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds double, double* %435, i64 %437
%439 = load double, double* %438
%440 = load double, double* %52
%441 = fadd double %440, %439
store double %441, double* %52
br label %442
442: ; preds = %411
%443 = load i64, i64* %26
%444 = add i64 %443, 1
store i64 %444, i64* %26
br label %406
445: ; preds = %406
%446 = load double, double* %52
%447 = call double @llvm.fabs.f64(double %446)
%448 = fcmp ogt double %447, 0x3D06849B86A12B9B
br i1 %448, label %449, label %462
449: ; preds = %445
%450 = load double, double* %49
%451 = load double, double* %52
%452 = fmul double %450, %451
%453 = load double*, double** %18
%454 = load i64, i64* %25
%455 = getelementptr inbounds double, double* %453, i64 %454
%456 = load double, double* %455
%457 = load double*, double** %21
%458 = load i64, i64* %24
%459 = getelementptr inbounds double, double* %457, i64 %458
%460 = load double, double* %459
%461 = call double @llvm.fmuladd.f64(double %452, double %456, double %460)
store double %461, double* %459
br label %462
462: ; preds = %449, %445
%463 = load i32*, i32** %50
%464 = call i32 @free(i32* %463)
%465 = load i32*, i32** %51
%466 = call i32 @free(i32* %465)
br label %632
467: ; preds = %303
%468 = load i32, i32* %37
%469 = icmp eq i32 %468, 0
br i1 %469, label %470, label %631
470: ; preds = %467
%471 = load i32*, i32** %34
%472 = load i32*, i32** %36
%473 = load i32, i32* %28
%474 = call i32* @get_single_excitation(i32* %471, i32* %472, i32 %473)
store i32* %474, i32** %46
%475 = load i32*, i32** %46
%476 = getelementptr inbounds i32, i32* %475, i64 0
%477 = load i32, i32* %476
store i32 %477, i32* %58
%478 = load i32*, i32** %46
%479 = getelementptr inbounds i32, i32* %478, i64 1
%480 = load i32, i32* %479
store i32 %480, i32* %59
%481 = load i32, i32* %59
%482 = load i32, i32* %58
%483 = load i32*, i32** %34
%484 = load i32, i32* %28
%485 = call double @compute_cre_des_sign(i32 %481, i32 %482, i32* %483, i32 %484)
store double %485, double* %60
%486 = load i32*, i32** %33
%487 = load i32, i32* %28
%488 = load i32, i32* %14
%489 = load i32, i32* %15
%490 = call i32* @compute_occ_list(i32* %486, i32 %487, i32 %488, i32 %489)
store i32* %490, i32** %61
%491 = load i32*, i32** %34
%492 = load i32, i32* %28
%493 = load i32, i32* %14
%494 = load i32, i32* %16
%495 = call i32* @compute_occ_list(i32* %491, i32 %492, i32 %493, i32 %494)
store i32* %495, i32** %62
%496 = load double*, double** %12
%497 = load i32, i32* %59
%498 = load i32, i32* %14
%499 = mul nsw i32 %497, %498
%500 = load i32, i32* %58
%501 = add nsw i32 %499, %500
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds double, double* %496, i64 %502
%504 = load double, double* %503
store double %504, double* %63
store i64 0, i64* %26
br label %505
505: ; preds = %566, %470
%506 = load i64, i64* %26
%507 = load i32, i32* %16
%508 = sext i32 %507 to i64
%509 = icmp ult i64 %506, %508
br i1 %509, label %510, label %569
510: ; preds = %505
%511 = load i32*, i32** %62
%512 = load i64, i64* %26
%513 = getelementptr inbounds i32, i32* %511, i64 %512
%514 = load i32, i32* %513
store i32 %514, i32* %64
%515 = load i32, i32* %64
%516 = load i32, i32* %14
%517 = mul nsw i32 %515, %516
%518 = load i32, i32* %14
%519 = mul nsw i32 %517, %518
%520 = load i32, i32* %14
%521 = mul nsw i32 %519, %520
%522 = load i32, i32* %64
%523 = load i32, i32* %14
%524 = mul nsw i32 %522, %523
%525 = load i32, i32* %14
%526 = mul nsw i32 %524, %525
%527 = add nsw i32 %521, %526
%528 = load i32, i32* %59
%529 = load i32, i32* %14
%530 = mul nsw i32 %528, %529
%531 = add nsw i32 %527, %530
%532 = load i32, i32* %58
%533 = add nsw i32 %531, %532
store i32 %533, i32* %65
%534 = load i32, i32* %64
%535 = load i32, i32* %14
%536 = mul nsw i32 %534, %535
%537 = load i32, i32* %14
%538 = mul nsw i32 %536, %537
%539 = load i32, i32* %14
%540 = mul nsw i32 %538, %539
%541 = load i32, i32* %58
%542 = load i32, i32* %14
%543 = mul nsw i32 %541, %542
%544 = load i32, i32* %14
%545 = mul nsw i32 %543, %544
%546 = add nsw i32 %540, %545
%547 = load i32, i32* %59
%548 = load i32, i32* %14
%549 = mul nsw i32 %547, %548
%550 = add nsw i32 %546, %549
%551 = load i32, i32* %64
%552 = add nsw i32 %550, %551
store i32 %552, i32* %66
%553 = load double*, double** %13
%554 = load i32, i32* %65
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double, double* %553, i64 %555
%557 = load double, double* %556
%558 = load double*, double** %13
%559 = load i32, i32* %66
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %558, i64 %560
%562 = load double, double* %561
%563 = fsub double %557, %562
%564 = load double, double* %63
%565 = fadd double %564, %563
store double %565, double* %63
br label %566
566: ; preds = %510
%567 = load i64, i64* %26
%568 = add i64 %567, 1
store i64 %568, i64* %26
br label %505
569: ; preds = %505
store i64 0, i64* %26
br label %570
570: ; preds = %606, %569
%571 = load i64, i64* %26
%572 = load i32, i32* %15
%573 = sext i32 %572 to i64
%574 = icmp ult i64 %571, %573
br i1 %574, label %575, label %609
575: ; preds = %570
%576 = load i32*, i32** %61
%577 = load i64, i64* %26
%578 = getelementptr inbounds i32, i32* %576, i64 %577
%579 = load i32, i32* %578
store i32 %579, i32* %67
%580 = load i32, i32* %67
%581 = load i32, i32* %14
%582 = mul nsw i32 %580, %581
%583 = load i32, i32* %14
%584 = mul nsw i32 %582, %583
%585 = load i32, i32* %14
%586 = mul nsw i32 %584, %585
%587 = load i32, i32* %67
%588 = load i32, i32* %14
%589 = mul nsw i32 %587, %588
%590 = load i32, i32* %14
%591 = mul nsw i32 %589, %590
%592 = add nsw i32 %586, %591
%593 = load i32, i32* %59
%594 = load i32, i32* %14
%595 = mul nsw i32 %593, %594
%596 = add nsw i32 %592, %595
%597 = load i32, i32* %58
%598 = add nsw i32 %596, %597
store i32 %598, i32* %68
%599 = load double*, double** %13
%600 = load i32, i32* %68
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %599, i64 %601
%603 = load double, double* %602
%604 = load double, double* %63
%605 = fadd double %604, %603
store double %605, double* %63
br label %606
606: ; preds = %575
%607 = load i64, i64* %26
%608 = add i64 %607, 1
store i64 %608, i64* %26
br label %570
609: ; preds = %570
%610 = load double, double* %63
%611 = call double @llvm.fabs.f64(double %610)
%612 = fcmp ogt double %611, 0x3D06849B86A12B9B
br i1 %612, label %613, label %626
613: ; preds = %609
%614 = load double, double* %60
%615 = load double, double* %63
%616 = fmul double %614, %615
%617 = load double*, double** %18
%618 = load i64, i64* %25
%619 = getelementptr inbounds double, double* %617, i64 %618
%620 = load double, double* %619
%621 = load double*, double** %21
%622 = load i64, i64* %24
%623 = getelementptr inbounds double, double* %621, i64 %622
%624 = load double, double* %623
%625 = call double @llvm.fmuladd.f64(double %616, double %620, double %624)
store double %625, double* %623
br label %626
626: ; preds = %613, %609
%627 = load i32*, i32** %61
%628 = call i32 @free(i32* %627)
%629 = load i32*, i32** %62
%630 = call i32 @free(i32* %629)
br label %631
631: ; preds = %626, %467
br label %632
632: ; preds = %631, %462
%633 = load i32*, i32** %46
%634 = call i32 @free(i32* %633)
br label %1006
635: ; preds = %298
%636 = load i32, i32* %37
%637 = load i32, i32* %38
%638 = add nsw i32 %636, %637
%639 = icmp eq i32 %638, 2
br i1 %639, label %640, label %1005
640: ; preds = %635
%641 = load i32, i32* %38
%642 = icmp eq i32 %641, 0
br i1 %642, label %643, label %773
643: ; preds = %640
%644 = load i32*, i32** %33
%645 = load i32*, i32** %35
%646 = load i32, i32* %28
%647 = call i32* @get_double_excitation(i32* %644, i32* %645, i32 %646)
store i32* %647, i32** %73
%648 = load i32*, i32** %73
%649 = getelementptr inbounds i32, i32* %648, i64 0
%650 = load i32, i32* %649
store i32 %650, i32* %69
%651 = load i32*, i32** %73
%652 = getelementptr inbounds i32, i32* %651, i64 1
%653 = load i32, i32* %652
store i32 %653, i32* %70
%654 = load i32*, i32** %73
%655 = getelementptr inbounds i32, i32* %654, i64 2
%656 = load i32, i32* %655
store i32 %656, i32* %71
%657 = load i32*, i32** %73
%658 = getelementptr inbounds i32, i32* %657, i64 3
%659 = load i32, i32* %658
store i32 %659, i32* %72
%660 = load i32, i32* %71
%661 = load i32, i32* %14
%662 = mul nsw i32 %660, %661
%663 = load i32, i32* %14
%664 = mul nsw i32 %662, %663
%665 = load i32, i32* %14
%666 = mul nsw i32 %664, %665
%667 = load i32, i32* %70
%668 = load i32, i32* %14
%669 = mul nsw i32 %667, %668
%670 = load i32, i32* %14
%671 = mul nsw i32 %669, %670
%672 = add nsw i32 %666, %671
%673 = load i32, i32* %72
%674 = load i32, i32* %14
%675 = mul nsw i32 %673, %674
%676 = add nsw i32 %672, %675
%677 = load i32, i32* %69
%678 = add nsw i32 %676, %677
store i32 %678, i32* %76
%679 = load i32, i32* %71
%680 = load i32, i32* %14
%681 = mul nsw i32 %679, %680
%682 = load i32, i32* %14
%683 = mul nsw i32 %681, %682
%684 = load i32, i32* %14
%685 = mul nsw i32 %683, %684
%686 = load i32, i32* %69
%687 = load i32, i32* %14
%688 = mul nsw i32 %686, %687
%689 = load i32, i32* %14
%690 = mul nsw i32 %688, %689
%691 = add nsw i32 %685, %690
%692 = load i32, i32* %72
%693 = load i32, i32* %14
%694 = mul nsw i32 %692, %693
%695 = add nsw i32 %691, %694
%696 = load i32, i32* %70
%697 = add nsw i32 %695, %696
store i32 %697, i32* %77
%698 = load i32, i32* %71
%699 = load i32, i32* %70
%700 = icmp sgt i32 %698, %699
br i1 %700, label %705, label %701
701: ; preds = %643
%702 = load i32, i32* %69
%703 = load i32, i32* %72
%704 = icmp sgt i32 %702, %703
br i1 %704, label %705, label %729
705: ; preds = %701, %643
%706 = load double*, double** %13
%707 = load i32, i32* %76
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %706, i64 %708
%710 = load double, double* %709
%711 = load double*, double** %13
%712 = load i32, i32* %77
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds double, double* %711, i64 %713
%715 = load double, double* %714
%716 = fsub double %710, %715
store double %716, double* %74
%717 = load i32, i32* %72
%718 = load i32, i32* %69
%719 = load i32*, i32** %33
%720 = load i32, i32* %28
%721 = call double @compute_cre_des_sign(i32 %717, i32 %718, i32* %719, i32 %720)
store double %721, double* %75
%722 = load i32, i32* %71
%723 = load i32, i32* %70
%724 = load i32*, i32** %33
%725 = load i32, i32* %28
%726 = call double @compute_cre_des_sign(i32 %722, i32 %723, i32* %724, i32 %725)
%727 = load double, double* %75
%728 = fmul double %727, %726
store double %728, double* %75
br label %753
729: ; preds = %701
%730 = load double*, double** %13
%731 = load i32, i32* %77
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds double, double* %730, i64 %732
%734 = load double, double* %733
%735 = load double*, double** %13
%736 = load i32, i32* %76
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds double, double* %735, i64 %737
%739 = load double, double* %738
%740 = fsub double %734, %739
store double %740, double* %74
%741 = load i32, i32* %72
%742 = load i32, i32* %70
%743 = load i32*, i32** %33
%744 = load i32, i32* %28
%745 = call double @compute_cre_des_sign(i32 %741, i32 %742, i32* %743, i32 %744)
store double %745, double* %75
%746 = load i32, i32* %71
%747 = load i32, i32* %69
%748 = load i32*, i32** %33
%749 = load i32, i32* %28
%750 = call double @compute_cre_des_sign(i32 %746, i32 %747, i32* %748, i32 %749)
%751 = load double, double* %75
%752 = fmul double %751, %750
store double %752, double* %75
br label %753
753: ; preds = %729, %705
%754 = load double, double* %74
%755 = call double @llvm.fabs.f64(double %754)
%756 = fcmp ogt double %755, 0x3D06849B86A12B9B
br i1 %756, label %757, label %770
757: ; preds = %753
%758 = load double, double* %75
%759 = load double, double* %74
%760 = fmul double %758, %759
%761 = load double*, double** %18
%762 = load i64, i64* %25
%763 = getelementptr inbounds double, double* %761, i64 %762
%764 = load double, double* %763
%765 = load double*, double** %21
%766 = load i64, i64* %24
%767 = getelementptr inbounds double, double* %765, i64 %766
%768 = load double, double* %767
%769 = call double @llvm.fmuladd.f64(double %760, double %764, double %768)
store double %769, double* %767
br label %770
770: ; preds = %757, %753
%771 = load i32*, i32** %73
%772 = call i32 @free(i32* %771)
br label %1004
773: ; preds = %640
%774 = load i32, i32* %37
%775 = icmp eq i32 %774, 0
br i1 %775, label %776, label %906
776: ; preds = %773
%777 = load i32*, i32** %34
%778 = load i32*, i32** %36
%779 = load i32, i32* %28
%780 = call i32* @get_double_excitation(i32* %777, i32* %778, i32 %779)
store i32* %780, i32** %78
%781 = load i32*, i32** %78
%782 = getelementptr inbounds i32, i32* %781, i64 0
%783 = load i32, i32* %782
store i32 %783, i32* %69
%784 = load i32*, i32** %78
%785 = getelementptr inbounds i32, i32* %784, i64 1
%786 = load i32, i32* %785
store i32 %786, i32* %70
%787 = load i32*, i32** %78
%788 = getelementptr inbounds i32, i32* %787, i64 2
%789 = load i32, i32* %788
store i32 %789, i32* %71
%790 = load i32*, i32** %78
%791 = getelementptr inbounds i32, i32* %790, i64 3
%792 = load i32, i32* %791
store i32 %792, i32* %72
%793 = load i32, i32* %71
%794 = load i32, i32* %14
%795 = mul nsw i32 %793, %794
%796 = load i32, i32* %14
%797 = mul nsw i32 %795, %796
%798 = load i32, i32* %14
%799 = mul nsw i32 %797, %798
%800 = load i32, i32* %70
%801 = load i32, i32* %14
%802 = mul nsw i32 %800, %801
%803 = load i32, i32* %14
%804 = mul nsw i32 %802, %803
%805 = add nsw i32 %799, %804
%806 = load i32, i32* %72
%807 = load i32, i32* %14
%808 = mul nsw i32 %806, %807
%809 = add nsw i32 %805, %808
%810 = load i32, i32* %69
%811 = add nsw i32 %809, %810
store i32 %811, i32* %81
%812 = load i32, i32* %71
%813 = load i32, i32* %14
%814 = mul nsw i32 %812, %813
%815 = load i32, i32* %14
%816 = mul nsw i32 %814, %815
%817 = load i32, i32* %14
%818 = mul nsw i32 %816, %817
%819 = load i32, i32* %69
%820 = load i32, i32* %14
%821 = mul nsw i32 %819, %820
%822 = load i32, i32* %14
%823 = mul nsw i32 %821, %822
%824 = add nsw i32 %818, %823
%825 = load i32, i32* %72
%826 = load i32, i32* %14
%827 = mul nsw i32 %825, %826
%828 = add nsw i32 %824, %827
%829 = load i32, i32* %70
%830 = add nsw i32 %828, %829
store i32 %830, i32* %82
%831 = load i32, i32* %71
%832 = load i32, i32* %70
%833 = icmp sgt i32 %831, %832
br i1 %833, label %838, label %834
834: ; preds = %776
%835 = load i32, i32* %69
%836 = load i32, i32* %72
%837 = icmp sgt i32 %835, %836
br i1 %837, label %838, label %862
838: ; preds = %834, %776
%839 = load double*, double** %13
%840 = load i32, i32* %81
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds double, double* %839, i64 %841
%843 = load double, double* %842
%844 = load double*, double** %13
%845 = load i32, i32* %82
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds double, double* %844, i64 %846
%848 = load double, double* %847
%849 = fsub double %843, %848
store double %849, double* %79
%850 = load i32, i32* %72
%851 = load i32, i32* %69
%852 = load i32*, i32** %34
%853 = load i32, i32* %28
%854 = call double @compute_cre_des_sign(i32 %850, i32 %851, i32* %852, i32 %853)
store double %854, double* %80
%855 = load i32, i32* %71
%856 = load i32, i32* %70
%857 = load i32*, i32** %34
%858 = load i32, i32* %28
%859 = call double @compute_cre_des_sign(i32 %855, i32 %856, i32* %857, i32 %858)
%860 = load double, double* %80
%861 = fmul double %860, %859
store double %861, double* %80
br label %886
862: ; preds = %834
%863 = load double*, double** %13
%864 = load i32, i32* %82
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds double, double* %863, i64 %865
%867 = load double, double* %866
%868 = load double*, double** %13
%869 = load i32, i32* %81
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds double, double* %868, i64 %870
%872 = load double, double* %871
%873 = fsub double %867, %872
store double %873, double* %79
%874 = load i32, i32* %72
%875 = load i32, i32* %70
%876 = load i32*, i32** %34
%877 = load i32, i32* %28
%878 = call double @compute_cre_des_sign(i32 %874, i32 %875, i32* %876, i32 %877)
store double %878, double* %80
%879 = load i32, i32* %71
%880 = load i32, i32* %69
%881 = load i32*, i32** %34
%882 = load i32, i32* %28
%883 = call double @compute_cre_des_sign(i32 %879, i32 %880, i32* %881, i32 %882)
%884 = load double, double* %80
%885 = fmul double %884, %883
store double %885, double* %80
br label %886
886: ; preds = %862, %838
%887 = load double, double* %79
%888 = call double @llvm.fabs.f64(double %887)
%889 = fcmp ogt double %888, 0x3D06849B86A12B9B
br i1 %889, label %890, label %903
890: ; preds = %886
%891 = load double, double* %80
%892 = load double, double* %79
%893 = fmul double %891, %892
%894 = load double*, double** %18
%895 = load i64, i64* %25
%896 = getelementptr inbounds double, double* %894, i64 %895
%897 = load double, double* %896
%898 = load double*, double** %21
%899 = load i64, i64* %24
%900 = getelementptr inbounds double, double* %898, i64 %899
%901 = load double, double* %900
%902 = call double @llvm.fmuladd.f64(double %893, double %897, double %901)
store double %902, double* %900
br label %903
903: ; preds = %890, %886
%904 = load i32*, i32** %78
%905 = call i32 @free(i32* %904)
br label %1003
906: ; preds = %773
%907 = load i32*, i32** %33
%908 = load i32*, i32** %35
%909 = load i32, i32* %28
%910 = call i32* @get_single_excitation(i32* %907, i32* %908, i32 %909)
store i32* %910, i32** %83
%911 = load i32*, i32** %34
%912 = load i32*, i32** %36
%913 = load i32, i32* %28
%914 = call i32* @get_single_excitation(i32* %911, i32* %912, i32 %913)
store i32* %914, i32** %84
%915 = load i32*, i32** %83
%916 = getelementptr inbounds i32, i32* %915, i64 0
%917 = load i32, i32* %916
store i32 %917, i32* %69
%918 = load i32*, i32** %83
%919 = getelementptr inbounds i32, i32* %918, i64 1
%920 = load i32, i32* %919
store i32 %920, i32* %71
%921 = load i32*, i32** %84
%922 = getelementptr inbounds i32, i32* %921, i64 0
%923 = load i32, i32* %922
store i32 %923, i32* %70
%924 = load i32*, i32** %84
%925 = getelementptr inbounds i32, i32* %924, i64 1
%926 = load i32, i32* %925
store i32 %926, i32* %72
%927 = load double*, double** %13
%928 = load i32, i32* %71
%929 = load i32, i32* %14
%930 = mul nsw i32 %928, %929
%931 = load i32, i32* %14
%932 = mul nsw i32 %930, %931
%933 = load i32, i32* %14
%934 = mul nsw i32 %932, %933
%935 = load i32, i32* %69
%936 = load i32, i32* %14
%937 = mul nsw i32 %935, %936
%938 = load i32, i32* %14
%939 = mul nsw i32 %937, %938
%940 = add nsw i32 %934, %939
%941 = load i32, i32* %72
%942 = load i32, i32* %14
%943 = mul nsw i32 %941, %942
%944 = add nsw i32 %940, %943
%945 = load i32, i32* %70
%946 = add nsw i32 %944, %945
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds double, double* %927, i64 %947
%949 = load double, double* %948
store double %949, double* %85
%950 = load i32, i32* %71
%951 = load i32, i32* %69
%952 = load i32*, i32** %33
%953 = load i32, i32* %28
%954 = call double @compute_cre_des_sign(i32 %950, i32 %951, i32* %952, i32 %953)
store double %954, double* %86
%955 = load i32, i32* %72
%956 = load i32, i32* %70
%957 = load i32*, i32** %34
%958 = load i32, i32* %28
%959 = call double @compute_cre_des_sign(i32 %955, i32 %956, i32* %957, i32 %958)
%960 = load double, double* %86
%961 = fmul double %960, %959
store double %961, double* %86
%962 = load double, double* %85
%963 = call double @llvm.fabs.f64(double %962)
%964 = fcmp ogt double %963, 0x3D06849B86A12B9B
br i1 %964, label %965, label %978
965: ; preds = %906
%966 = load double, double* %86
%967 = load double, double* %85
%968 = fmul double %966, %967
%969 = load double*, double** %18
%970 = load i64, i64* %25
%971 = getelementptr inbounds double, double* %969, i64 %970
%972 = load double, double* %971
%973 = load double*, double** %21
%974 = load i64, i64* %24
%975 = getelementptr inbounds double, double* %973, i64 %974
%976 = load double, double* %975
%977 = call double @llvm.fmuladd.f64(double %968, double %972, double %976)
store double %977, double* %975
br label %978
978: ; preds = %965, %906
%979 = load i32, i32* %69
%980 = load i32, i32* %72
%981 = icmp eq i32 %979, %980
br i1 %981, label %982, label %998
982: ; preds = %978
%983 = load i32, i32* %70
%984 = load i32, i32* %71
%985 = icmp eq i32 %983, %984
br i1 %985, label %986, label %998
986: ; preds = %982
%987 = load double, double* %86
%988 = load double*, double** %18
%989 = load i64, i64* %25
%990 = getelementptr inbounds double, double* %988, i64 %989
%991 = load double, double* %990
%992 = load double*, double** %22
%993 = load i64, i64* %24
%994 = getelementptr inbounds double, double* %992, i64 %993
%995 = load double, double* %994
%996 = fneg double %987
%997 = call double @llvm.fmuladd.f64(double %996, double %991, double %995)
store double %997, double* %994
br label %998
998: ; preds = %986, %982, %978
%999 = load i32*, i32** %83
%1000 = call i32 @free(i32* %999)
%1001 = load i32*, i32** %84
%1002 = call i32 @free(i32* %1001)
br label %1003
1003: ; preds = %998, %903
br label %1004
1004: ; preds = %1003, %770
br label %1005
1005: ; preds = %1004, %635
br label %1006
1006: ; preds = %1005, %632
br label %1007
1007: ; preds = %1006, %283
br label %1008
1008: ; preds = %1007, %152
br label %1009
1009: ; preds = %1008
%1010 = load i64, i64* %25
%1011 = add i64 %1010, 1
store i64 %1011, i64* %25
br label %147
1012: ; preds = %147
br label %1013
1013: ; preds = %1012
%1014 = load i64, i64* %24
%1015 = add i64 %1014, 1
store i64 %1015, i64* %24
br label %141
1016: ; preds = %141
%1017 = load i32*, i32** %23
%1018 = call i32 @free(i32* %1017)
ret void
}

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