// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_cl_at_l
int harmonic_cl_at_l(
                     struct harmonic * phr,
                     double l,
                     double * cl_tot,    /* array with argument cl_tot[index_ct] (must be already allocated) */
                     double * * cl_md,   /* array with argument cl_md[index_md][index_ct] (must be already allocated only if several modes) */
                     double * * cl_md_ic /* array with argument cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct] (must be already allocated for a given mode only if several ic's) */
                     ) {

  /** Summary: */

  /** - define local variables */

  int last_index;
  int index_md;
  int index_ic1,index_ic2,index_ic1_ic2;
  int index_ct;

  /** - (a) treat case in which there is only one mode and one initial condition.
      Then, only cl_tot needs to be filled. */

  if ((phr->md_size == 1) && (phr->ic_size[0] == 1)) {
    index_md = 0;
    if ((int)l <= phr->l[phr->l_size[index_md]-1]) {

      /* interpolate at l */
      class_call(array_interpolate_spline(phr->l,
                                          phr->l_size[index_md],
                                          phr->cl[index_md],
                                          phr->ddcl[index_md],
                                          phr->ct_size,
                                          l,
                                          &last_index,
                                          cl_tot,
                                          phr->ct_size,
                                          phr->error_message),
                 phr->error_message,
                 phr->error_message);

      /* set to zero for the types such that l<l_max */
      for (index_ct=0; index_ct<phr->ct_size; index_ct++)
        if ((int)l > phr->l_max_ct[index_md][index_ct])
          cl_tot[index_ct]=0.;
    }
    else {
      for (index_ct=0; index_ct<phr->ct_size; index_ct++)
        cl_tot[index_ct]=0.;
    }
  }

  /** - (b) treat case in which there is only one mode
      with several initial condition.
      Fill cl_md_ic[index_md=0] and sum it to get cl_tot. */

  if ((phr->md_size == 1) && (phr->ic_size[0] > 1)) {
    index_md = 0;
    for (index_ct=0; index_ct<phr->ct_size; index_ct++)
      cl_tot[index_ct]=0.;
    for (index_ic1 = 0; index_ic1 < phr->ic_size[index_md]; index_ic1++) {
      for (index_ic2 = index_ic1; index_ic2 < phr->ic_size[index_md]; index_ic2++) {
        index_ic1_ic2 = index_symmetric_matrix(index_ic1,index_ic2,phr->ic_size[index_md]);
        if (((int)l <= phr->l[phr->l_size[index_md]-1]) &&
            (phr->is_non_zero[index_md][index_ic1_ic2] == _TRUE_)) {

          class_call(array_interpolate_spline(phr->l,
                                              phr->l_size[index_md],
                                              phr->cl[index_md],
                                              phr->ddcl[index_md],
                                              phr->ic_ic_size[index_md]*phr->ct_size,
                                              l,
                                              &last_index,
                                              cl_md_ic[index_md],
                                              phr->ic_ic_size[index_md]*phr->ct_size,
                                              phr->error_message),
                     phr->error_message,
                     phr->error_message);

          for (index_ct=0; index_ct<phr->ct_size; index_ct++)
            if ((int)l > phr->l_max_ct[index_md][index_ct])
              cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct]=0.;
        }
        else {
          for (index_ct=0; index_ct<phr->ct_size; index_ct++)
            cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct]=0.;
        }

        /* compute cl_tot by summing over cl_md_ic */
        for (index_ct=0; index_ct<phr->ct_size; index_ct++) {
          if (index_ic1 == index_ic2)
            cl_tot[index_ct]+=cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct];
          else
            cl_tot[index_ct]+=2.*cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct];
        }
      }
    }
  }

  /** - (c) loop over modes */

  if (phr->md_size > 1) {

    for (index_ct=0; index_ct<phr->ct_size; index_ct++)
      cl_tot[index_ct]=0.;

    for (index_md = 0; index_md < phr->md_size; index_md++) {

      /** - --> (c.1.) treat case in which the mode under consideration
          has only one initial condition.
          Fill cl_md[index_md]. */

      if (phr->ic_size[index_md] == 1) {
        if ((int)l <= phr->l[phr->l_size[index_md]-1]) {

          class_call(array_interpolate_spline(phr->l,
                                              phr->l_size[index_md],
                                              phr->cl[index_md],
                                              phr->ddcl[index_md],
                                              phr->ct_size,
                                              l,
                                              &last_index,
                                              cl_md[index_md],
                                              phr->ct_size,
                                              phr->error_message),
                     phr->error_message,
                     phr->error_message);

          for (index_ct=0; index_ct<phr->ct_size; index_ct++)
            if ((int)l > phr->l_max_ct[index_md][index_ct])
              cl_md[index_md][index_ct]=0.;
        }
        else {
          for (index_ct=0; index_ct<phr->ct_size; index_ct++)
            cl_md[index_md][index_ct]=0.;
        }
      }

      /** - --> (c.2.) treat case in which the mode under consideration
          has several initial conditions.
          Fill cl_md_ic[index_md] and sum it to get cl_md[index_md] */

      if (phr->ic_size[index_md] > 1) {

        if ((int)l <= phr->l[phr->l_size[index_md]-1]) {

          /* interpolate all ic and ct */
          class_call(array_interpolate_spline(phr->l,
                                              phr->l_size[index_md],
                                              phr->cl[index_md],
                                              phr->ddcl[index_md],
                                              phr->ic_ic_size[index_md]*phr->ct_size,
                                              l,
                                              &last_index,
                                              cl_md_ic[index_md],
                                              phr->ic_ic_size[index_md]*phr->ct_size,
                                              phr->error_message),
                     phr->error_message,
                     phr->error_message);

          /* set to zero some of the components */
          for (index_ic1 = 0; index_ic1 < phr->ic_size[index_md]; index_ic1++) {
            for (index_ic2 = index_ic1; index_ic2 < phr->ic_size[index_md]; index_ic2++) {
              index_ic1_ic2 = index_symmetric_matrix(index_ic1,index_ic2,phr->ic_size[index_md]);
              for (index_ct=0; index_ct<phr->ct_size; index_ct++) {

                if (((int)l > phr->l_max_ct[index_md][index_ct]) || (phr->is_non_zero[index_md][index_ic1_ic2] == _FALSE_))
                  cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct]=0.;
              }
            }
          }
        }
        /* if l was too big, set anyway all components to zero */
        else {
          for (index_ic1 = 0; index_ic1 < phr->ic_size[index_md]; index_ic1++) {
            for (index_ic2 = index_ic1; index_ic2 < phr->ic_size[index_md]; index_ic2++) {
              index_ic1_ic2 = index_symmetric_matrix(index_ic1,index_ic2,phr->ic_size[index_md]);
              for (index_ct=0; index_ct<phr->ct_size; index_ct++) {
                cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct]=0.;
              }
            }
          }
        }

        /* sum up all ic for each mode */

        for (index_ct=0; index_ct<phr->ct_size; index_ct++) {

          cl_md[index_md][index_ct]=0.;

          for (index_ic1 = 0; index_ic1 < phr->ic_size[index_md]; index_ic1++) {
            for (index_ic2 = index_ic1; index_ic2 < phr->ic_size[index_md]; index_ic2++) {
              index_ic1_ic2 = index_symmetric_matrix(index_ic1,index_ic2,phr->ic_size[index_md]);

              if (index_ic1 == index_ic2)
                cl_md[index_md][index_ct]+=cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct];
              else
                cl_md[index_md][index_ct]+=2.*cl_md_ic[index_md][index_ic1_ic2*phr->ct_size+index_ct];
            }
          }
        }
      }

      /** - --> (c.3.) add contribution of cl_md[index_md] to cl_tot */

      for (index_ct=0; index_ct<phr->ct_size; index_ct++)
        cl_tot[index_ct]+=cl_md[index_md][index_ct];
    }
  }

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x878, %rsp            # imm = 0x878
movq %rcx, %rbx
movq %rdx, 0x20(%rsp)
movq %rsi, %r10
movapd %xmm0, %xmm2
movq %rdi, %r9
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
movq %rsi, 0x30(%rsp)
movapd %xmm0, 0x50(%rsp)
jne 0xacada
movq 0x18(%r9), %rax
cmpl $0x1, (%rax)
jne 0xac887
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm0
movq 0xa0(%r9), %rax
movq 0xb0(%r9), %rdi
movslq (%rax), %rsi
movsd -0x8(%rdi,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0xac7bd
movl 0x9c(%r9), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0xac887
andq $0x0, (%r10,%rcx,8)
incq %rcx
jmp 0xac7aa
movq 0xd0(%r9), %rax
movq (%rax), %rdx
movq 0xd8(%r9), %rax
movq (%rax), %rcx
movl 0x9c(%r9), %r8d
leaq 0xea(%r9), %r13
subq $0x8, %rsp
movq %r9, %r14
leaq 0x24(%rsp), %r9
movapd %xmm2, %xmm0
pushq %r13
pushq %r8
pushq %r10
callq 0x1604b
addq $0x20, %rsp
cmpl $0x1, %eax
jne 0xac83c
leaq 0x38be6(%rip), %rsi     # 0xe53f0
leaq 0x6bd75(%rip), %rdx     # 0x118586
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3880a(%rip), %rsi     # 0xe5034
leaq 0x6bdfd(%rip), %rdx     # 0x11862e
pushq $0x49
popq %rcx
movq %r13, %rdi
jmp 0xacfc0
movapd 0x50(%rsp), %xmm2
cvttsd2si %xmm2, %eax
movl 0x9c(%r14), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movq 0x30(%rsp), %r10
movq %r14, %r9
cmpq %rdx, %rcx
je 0xac87a
movq 0xb8(%r9), %rsi
movq (%rsi), %rsi
cmpl %eax, (%rsi,%rdx,4)
jge 0xac875
andq $0x0, (%r10,%rdx,8)
incq %rdx
jmp 0xac85c
movl 0x10(%r9), %eax
cmpl $0x1, %eax
jne 0xacada
movq 0x18(%r9), %rax
movl (%rax), %ecx
cmpl $0x2, %ecx
jl 0xacf41
movl 0x9c(%r9), %eax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
cmpq %rdx, %rsi
je 0xac8b8
andq $0x0, (%r10,%rdx,8)
incq %rdx
jmp 0xac8a9
cvttsd2si %xmm2, %r11d
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm1
leaq 0xea(%r9), %rdx
movq %rdx, 0x8(%rsp)
xorl %r15d, %r15d
movl %eax, %r8d
xorl %r14d, %r14d
movapd %xmm1, 0x40(%rsp)
cmpl %ecx, %r14d
jge 0xacad6
leal 0x1(%r14), %edx
movl %edx, 0x28(%rsp)
movl %edx, %r12d
imull %r14d, %r12d
shrl %r12d
movl %r14d, %r13d
movl %r12d, 0x14(%rsp)
cmpl %ecx, %r13d
jge 0xaca8c
cmpl %r13d, %r14d
jbe 0xac928
imull %r13d, %ecx
addl %r14d, %ecx
leal 0x1(%r13), %edx
imull %r13d, %edx
shrl %edx
subl %edx, %ecx
movl %ecx, %ebp
jmp 0xac934
imull %r14d, %ecx
movl %r13d, %ebp
subl %r12d, %ebp
addl %ecx, %ebp
movq 0xa0(%r9), %rcx
movq 0xb0(%r9), %rdi
movslq (%rcx), %rsi
movsd -0x8(%rdi,%rsi,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xaca18
movq 0x28(%r9), %rcx
movq (%rcx), %rcx
movslq %ebp, %rdx
cmpw $0x1, (%rcx,%rdx,2)
jne 0xaca18
movl %r11d, %r12d
movq 0x20(%r9), %rax
movq 0xd0(%r9), %rcx
movq (%rcx), %rdx
movq 0xd8(%r9), %rcx
movq (%rcx), %rcx
imull (%rax), %r8d
subq $0x8, %rsp
movapd %xmm2, %xmm0
movq %r9, %r15
leaq 0x24(%rsp), %r9
pushq 0x10(%rsp)
pushq %r8
pushq (%rbx)
callq 0x1604b
addq $0x20, %rsp
cmpl $0x1, %eax
je 0xaca98
movl 0x9c(%r15), %eax
imull %eax, %ebp
movslq %ebp, %rcx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
leaq (,%rcx,8), %rsi
xorl %edi, %edi
movq 0x30(%rsp), %r10
movapd 0x50(%rsp), %xmm2
movq %r15, %r9
movl %r12d, %r11d
movapd 0x40(%rsp), %xmm1
xorl %r15d, %r15d
movl 0x14(%rsp), %r12d
cmpq %rdi, %rdx
je 0xaca4b
movq 0xb8(%r9), %r8
movq (%r8), %r8
cmpl %r11d, (%r8,%rdi,4)
jge 0xaca13
movq (%rbx), %r8
addq %rsi, %r8
andq $0x0, (%r8,%rdi,8)
incq %rdi
jmp 0xac9f3
movl %r8d, %ecx
imull %ebp, %ecx
movslq %ecx, %rcx
testl %r8d, %r8d
cmovlel %r15d, %r8d
subq $0x1, %r8
jb 0xaca3b
movq (%rbx), %rdx
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0xaca28
imull %eax, %ebp
movslq %ebp, %rcx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
shlq $0x3, %rcx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xaca7b
movq (%rbx), %rdi
addq %rcx, %rdi
movsd (%rdi,%rsi,8), %xmm0
cmpl %r13d, %r14d
je 0xaca6a
addsd %xmm0, %xmm0
addsd (%r10,%rsi,8), %xmm0
movsd %xmm0, (%r10,%rsi,8)
incq %rsi
jmp 0xaca51
incl %r13d
movq 0x18(%r9), %rcx
movl (%rcx), %ecx
movl %eax, %r8d
jmp 0xac903
movl 0x28(%rsp), %edx
movl %edx, %r14d
jmp 0xac8e0
leaq 0x38951(%rip), %rsi     # 0xe53f0
leaq 0x6bb99(%rip), %rdx     # 0x11863f
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x38570(%rip), %rsi     # 0xe5034
leaq 0x6bb63(%rip), %rdx     # 0x11862e
pushq $0x6f
popq %rcx
movq %r14, %rdi
jmp 0xacfc0
movl 0x10(%r9), %eax
cmpl $0x2, %eax
jl 0xacf41
movl 0x9c(%r9), %r8d
xorl %ecx, %ecx
testl %r8d, %r8d
movl $0x0, %edx
cmovgl %r8d, %edx
movq 0x20(%rsp), %rsi
cmpq %rcx, %rdx
je 0xacb0c
andq $0x0, (%r10,%rcx,8)
incq %rcx
jmp 0xacafd
cvttsd2si %xmm2, %ecx
movl %ecx, 0x14(%rsp)
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm3
leaq 0xea(%r9), %rcx
movq %rcx, 0x38(%rsp)
xorl %r13d, %r13d
movq %r9, %rbp
movapd %xmm3, 0x60(%rsp)
cltq
cmpq %rax, %r13
jge 0xacf41
movq 0x18(%r9), %rax
movl (%rax,%r13,4), %eax
movq %rax, 0x8(%rsp)
cmpl $0x1, %eax
jne 0xacc46
movq 0xa0(%r9), %rax
movq 0xb0(%r9), %rdi
movslq (%rax,%r13,4), %rsi
movsd -0x8(%rdi,%rsi,8), %xmm0
ucomisd %xmm3, %xmm0
jae 0xacb9d
testl %r8d, %r8d
movl $0x0, %eax
cmovgl %r8d, %eax
xorl %ecx, %ecx
movq 0x20(%rsp), %rsi
cmpq %rcx, %rax
je 0xacf08
movq (%rsi,%r13,8), %rdx
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0xacb86
movq 0xd0(%r9), %rax
movq 0xd8(%r9), %rcx
movq (%rax,%r13,8), %rdx
movq (%rcx,%r13,8), %rcx
subq $0x8, %rsp
movapd %xmm2, %xmm0
movq %r9, %r14
leaq 0x24(%rsp), %r9
pushq 0x40(%rsp)
pushq %r8
movq 0x38(%rsp), %rax
pushq (%rax,%r13,8)
callq 0x1604b
addq $0x20, %rsp
cmpl $0x1, %eax
je 0xacf48
movl 0x9c(%r14), %r8d
testl %r8d, %r8d
movl $0x0, %eax
cmovgl %r8d, %eax
xorl %ecx, %ecx
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %r10
movapd 0x50(%rsp), %xmm2
movq %r14, %r9
movapd 0x60(%rsp), %xmm3
cmpq %rcx, %rax
je 0xacc39
movq 0xb8(%r9), %rdx
movq (%rdx,%r13,8), %rdx
movl 0x14(%rsp), %edi
cmpl %edi, (%rdx,%rcx,4)
jge 0xacc34
movq (%rsi,%r13,8), %rdx
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0xacc12
movq 0x18(%r9), %rax
movl (%rax,%r13,4), %eax
movq %rax, 0x8(%rsp)
cmpl $0x2, 0x8(%rsp)
jl 0xacf08
movq 0xa0(%r9), %rax
movq 0xb0(%r9), %rdi
movslq (%rax,%r13,4), %rsi
movsd -0x8(%rdi,%rsi,8), %xmm0
ucomisd %xmm3, %xmm0
jae 0xacce6
xorl %ecx, %ecx
testl %r8d, %r8d
movl $0x0, %edx
cmovgl %r8d, %edx
movq 0x8(%rsp), %rax
leal 0x1(%rax), %esi
pushq $0x2
popq %rdi
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpl 0x8(%rsp), %r10d
je 0xace20
movl %ecx, %eax
shrl %eax
movl %r9d, %r14d
subl %eax, %r14d
imull %r8d, %r14d
leal 0x1(%r10), %r11d
cmpl 0x8(%rsp), %r10d
je 0xaccd9
movslq %r14d, %rax
shlq $0x3, %rax
movq %rdx, %r15
subq $0x1, %r15
jb 0xaccd1
movq (%rbx,%r13,8), %r12
andq $0x0, (%r12,%rax)
addq $0x8, %rax
jmp 0xaccbc
incl %r10d
addl %r8d, %r14d
jmp 0xaccab
addl %esi, %r9d
addl %edi, %ecx
addl $0x2, %edi
movl %r11d, %r10d
jmp 0xacc8e
movq 0x20(%r9), %rax
movq 0xd0(%r9), %rcx
movq (%rcx,%r13,8), %rdx
movq 0xd8(%r9), %rcx
movq (%rcx,%r13,8), %rcx
imull (%rax,%r13,4), %r8d
subq $0x8, %rsp
movapd %xmm2, %xmm0
movq %r9, %r14
leaq 0x24(%rsp), %r9
pushq 0x40(%rsp)
pushq %r8
pushq (%rbx,%r13,8)
callq 0x1604b
addq $0x20, %rsp
cmpl $0x1, %eax
je 0xacf85
movq 0x18(%r14), %rax
movl (%rax,%r13,4), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movl %edx, 0x28(%rsp)
movq %rax, 0x8(%rsp)
incl %eax
movl %eax, 0x18(%rsp)
pushq $0x2
popq %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movapd 0x50(%rsp), %xmm2
movapd 0x60(%rsp), %xmm3
cmpl 0x28(%rsp), %r9d
je 0xace25
movl %ecx, 0x40(%rsp)
movl %ecx, %eax
shrl %eax
movl %r8d, %r11d
subl %eax, %r11d
movq 0x8(%rsp), %r14
imull %r9d, %r14d
leal 0x1(%r9), %r10d
movl %r10d, %eax
imull %r9d, %eax
shrl %eax
subl %eax, %r14d
cmpl 0x8(%rsp), %r9d
je 0xace0a
leal (%r14,%r9), %eax
movl 0x9c(%rbp), %edx
cltq
testl %edx, %edx
movl $0x0, %r15d
cmovgl %edx, %r15d
imull %r11d, %edx
movslq %edx, %rsi
shlq $0x3, %rsi
xorl %edx, %edx
cmpq %rdx, %r15
je 0xace02
movq 0xb8(%rbp), %r12
movq (%r12,%r13,8), %r12
movl 0x14(%rsp), %ecx
cmpl %ecx, (%r12,%rdx,4)
jl 0xacdf1
movq 0x28(%rbp), %r12
movq (%r12,%r13,8), %r12
cmpw $0x0, (%r12,%rax,2)
jne 0xacdfd
movq (%rbx,%r13,8), %r12
addq %rsi, %r12
andq $0x0, (%r12,%rdx,8)
incq %rdx
jmp 0xacdc7
incl %r9d
incl %r11d
jmp 0xacd9b
addl 0x18(%rsp), %r8d
movl 0x40(%rsp), %ecx
addl %edi, %ecx
addl $0x2, %edi
movl %r10d, %r9d
jmp 0xacd69
movq %rbp, %r9
jmp 0xace2f
movq %rbp, %r9
movl 0x9c(%rbp), %r8d
testl %r8d, %r8d
movl $0x0, %eax
cmovgl %r8d, %eax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movl %ecx, 0x40(%rsp)
movl %eax, %ecx
negl %ecx
movl %ecx, 0x18(%rsp)
incl %eax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
movq 0x30(%rsp), %r10
cmpq 0x28(%rsp), %rdi
je 0xacf03
movq 0x20(%rsp), %rax
movq (%rax,%r13,8), %r9
andq $0x0, (%r9,%rdi,8)
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
pushq $0x2
popq %r11
xorl %r15d, %r15d
movl 0x18(%rsp), %esi
xorl %ecx, %ecx
cmpl 0x40(%rsp), %ecx
je 0xacef3
movl %r10d, %eax
shrl %eax
movl %r15d, %r14d
subl %eax, %r14d
imull %r8d, %r14d
addl %edi, %r14d
incl %ecx
xorl %eax, %eax
cmpl %eax, %esi
je 0xacee3
movq (%rbx,%r13,8), %rdx
movslq %r14d, %r12
subl $0x1, %eax
jae 0xaceca
addsd (%rdx,%r12,8), %xmm0
jmp 0xaced8
movsd (%rdx,%r12,8), %xmm1
addsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r9,%rdi,8)
addl %r8d, %r14d
jmp 0xaceb2
incl %esi
addl 0x8(%rsp), %r15d
addl %r11d, %r10d
addl $0x2, %r11d
jmp 0xace96
incq %rdi
movq 0x30(%rsp), %r10
movq %rbp, %r9
jmp 0xace69
movq 0x20(%rsp), %rsi
testl %r8d, %r8d
movl $0x0, %eax
cmovgl %r8d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xacf35
movq (%rsi,%r13,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%r10,%rcx,8), %xmm0
movsd %xmm0, (%r10,%rcx,8)
incq %rcx
jmp 0xacf16
incq %r13
movl 0x10(%r9), %eax
jmp 0xacb34
xorl %eax, %eax
jmp 0xacfcd
leaq 0x384a1(%rip), %rsi     # 0xe53f0
leaq 0x6b7d1(%rip), %rdx     # 0x118727
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq 0x38(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x380c0(%rip), %rsi     # 0xe5034
leaq 0x6b6b3(%rip), %rdx     # 0x11862e
movq %r14, %rdi
movl $0xa0, %ecx
jmp 0xacfc0
leaq 0x38464(%rip), %rsi     # 0xe53f0
leaq 0x6b6ac(%rip), %rdx     # 0x11863f
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq 0x38(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x38083(%rip), %rsi     # 0xe5034
leaq 0x6b676(%rip), %rdx     # 0x11862e
movq %r14, %rdi
movl $0xc0, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x878, %rsp            # imm = 0x878
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq