// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_cls
int harmonic_cls(
                 struct precision * ppr,
                 struct background * pba,
                 struct perturbations * ppt,
                 struct transfer * ptr,
                 struct primordial * ppm,
                 struct harmonic * phr
                 ) {

  /** Summary: */

  /** - define local variables */

  int index_md;
  int index_ic1,index_ic2,index_ic1_ic2;
  int index_l;
  int index_ct;
  int cl_integrand_num_columns;

  /** - allocate pointers to arrays where results will be stored */

  class_alloc(phr->l_size,sizeof(int)*phr->md_size,phr->error_message);
  class_alloc(phr->cl,sizeof(double *)*phr->md_size,phr->error_message);
  class_alloc(phr->ddcl,sizeof(double *)*phr->md_size,phr->error_message);

  phr->l_size_max = ptr->l_size_max;
  class_alloc(phr->l,sizeof(double)*phr->l_size_max,phr->error_message);

  /** - store values of l */
  for (index_l=0; index_l < phr->l_size_max; index_l++) {
    phr->l[index_l] = (double)ptr->l[index_l];
  }

  /** - loop over modes (scalar, tensors, etc). For each mode: */

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

    /** - --> (a) store number of l values for this mode */

    phr->l_size[index_md] = ptr->l_size[index_md];

    /** - --> (b) allocate arrays where results will be stored */

    class_alloc(phr->cl[index_md],sizeof(double)*phr->l_size[index_md]*phr->ct_size*phr->ic_ic_size[index_md],phr->error_message);
    class_alloc(phr->ddcl[index_md],sizeof(double)*phr->l_size[index_md]*phr->ct_size*phr->ic_ic_size[index_md],phr->error_message);
    cl_integrand_num_columns = 1+phr->ct_size*2; /* one for k, ct_size for each type, ct_size for each second derivative of each type */

    /** - --> (c) loop over initial conditions */

    class_setup_parallel();

    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]);

        /* non-diagonal coefficients should be computed only if non-zero correlation */
        if (phr->is_non_zero[index_md][index_ic1_ic2] == _TRUE_) {

          /** - ---> loop over l values defined in the transfer module.
              For each l, compute the \f$ C_l\f$'s for all types (TT, TE, ...)
              by convolving primordial spectra with transfer  functions.
              This elementary task is assigned to harmonic_compute_cl() */

          for (index_l=0; index_l < ptr->l_size[index_md]; index_l++) {

            class_run_parallel(=,

              double * cl_integrand; /* array with argument cl_integrand[index_k*cl_integrand_num_columns+1+phr->index_ct] */
              double * cl_integrand_limber; /* similar array with same columns but different number of lines (less k values) */
              double * transfer_ic1; /* array with argument transfer_ic1[index_tt] */
              double * transfer_ic2; /* idem */
              double * primordial_pk;  /* array with argument primordial_pk[index_ic_ic]*/


              class_alloc(cl_integrand,
                          ptr->q_size*cl_integrand_num_columns*sizeof(double),
                          phr->error_message);

              cl_integrand_limber = NULL;
              if (ptr->do_lcmb_full_limber == _TRUE_) {
                class_alloc(cl_integrand_limber,
                            ptr->q_size_limber*cl_integrand_num_columns*sizeof(double),
                            phr->error_message);
              }

              class_alloc(primordial_pk,
                          phr->ic_ic_size[index_md]*sizeof(double),
                          phr->error_message);

              class_alloc(transfer_ic1,
                          ptr->tt_size[index_md]*sizeof(double),
                          phr->error_message);

              class_alloc(transfer_ic2,
                          ptr->tt_size[index_md]*sizeof(double),
                          phr->error_message);

              class_call(harmonic_compute_cl(ppr,
                                             pba,
                                             ppt,
                                             ptr,
                                             ppm,
                                             phr,
                                             index_md,
                                             index_ic1,
                                             index_ic2,
                                             index_l,
                                             cl_integrand_num_columns,
                                             cl_integrand,
                                             cl_integrand_limber,
                                             primordial_pk,
                                             transfer_ic1,
                                             transfer_ic2),
                         phr->error_message,
                         phr->error_message);

              free(cl_integrand);
              if (ptr->do_lcmb_full_limber == _TRUE_) {
                free(cl_integrand_limber);
              }
              free(primordial_pk);
              free(transfer_ic1);
              free(transfer_ic2);

              return _SUCCESS_;
            );
          } /* end of loop over l */

        }
        else {

          /* set non-diagonal coefficients to zero if pair of ic's uncorrelated */

          for (index_l=0; index_l < ptr->l_size[index_md]; index_l++) {
            for (index_ct=0; index_ct<phr->ct_size; index_ct++) {
              phr->cl[index_md]
                [(index_l * phr->ic_ic_size[index_md] + index_ic1_ic2) * phr->ct_size + index_ct]
                = 0.;
            }
          }
        }
      }
    }

    class_finish_parallel();

    /** - --> (d) now that for a given mode, all possible \f$ C_l\f$'s have been computed,
        compute second derivative of the array in which they are stored,
        in view of spline interpolation. */

    class_call(array_spline_table_lines(phr->l,
                                        phr->l_size[index_md],
                                        phr->cl[index_md],
                                        phr->ic_ic_size[index_md]*phr->ct_size,
                                        phr->ddcl[index_md],
                                        _SPLINE_EST_DERIV_,
                                        phr->error_message),
               phr->error_message,
               phr->error_message);
  }

  return _SUCCESS_;

}

// Assembly:
subq $0x39b8, %rsp           # imm = 0x39B8
movq %rdi, 0x39a8(%rsp)
movq %rsi, 0x39a0(%rsp)
movq %rdx, 0x3998(%rsp)
movq %rcx, 0x3990(%rsp)
movq %r8, 0x3988(%rsp)
movq %r9, 0x3980(%rsp)
movq 0x3980(%rsp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x8460
movq %rax, %rcx
movq 0x3980(%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x3980(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
jne 0x14edac
movq 0x3980(%rsp), %rax
movslq 0x10(%rax), %rax
shlq $0x2, %rax
movl %eax, 0x3960(%rsp)
leaq 0x3160(%rsp), %rdi
movl 0x3960(%rsp), %ecx
leaq 0x832a7(%rip), %rsi     # 0x1d2004
leaq 0xb72aa(%rip), %rdx     # 0x20600e
movb $0x0, %al
callq 0x5b9c0
movq 0x3980(%rsp), %rdi
addq $0xea, %rdi
leaq 0x3160(%rsp), %r8
leaq 0x832ab(%rip), %rsi     # 0x1d2034
leaq 0xb728a(%rip), %rdx     # 0x20601a
movl $0x2ae, %ecx            # imm = 0x2AE
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x39b4(%rsp)
jmp 0x14f97a
movq 0x3980(%rsp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, %rcx
movq 0x3980(%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x3980(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x14ee61
movq 0x3980(%rsp), %rax
movslq 0x10(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x315c(%rsp)
leaq 0x2950(%rsp), %rdi
movl 0x315c(%rsp), %ecx
leaq 0x831f2(%rip), %rsi     # 0x1d2004
leaq 0xb720e(%rip), %rdx     # 0x206027
movb $0x0, %al
callq 0x5b9c0
movq 0x3980(%rsp), %rdi
addq $0xea, %rdi
leaq 0x2950(%rsp), %r8
leaq 0x831f6(%rip), %rsi     # 0x1d2034
leaq 0xb71d5(%rip), %rdx     # 0x20601a
movl $0x2af, %ecx            # imm = 0x2AF
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x39b4(%rsp)
jmp 0x14f97a
movq 0x3980(%rsp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, %rcx
movq 0x3980(%rsp), %rax
movq %rcx, 0xd8(%rax)
movq 0x3980(%rsp), %rax
cmpq $0x0, 0xd8(%rax)
jne 0x14ef16
movq 0x3980(%rsp), %rax
movslq 0x10(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x294c(%rsp)
leaq 0x2140(%rsp), %rdi
movl 0x294c(%rsp), %ecx
leaq 0x8313d(%rip), %rsi     # 0x1d2004
leaq 0xb7161(%rip), %rdx     # 0x20602f
movb $0x0, %al
callq 0x5b9c0
movq 0x3980(%rsp), %rdi
addq $0xea, %rdi
leaq 0x2140(%rsp), %r8
leaq 0x83141(%rip), %rsi     # 0x1d2034
leaq 0xb7120(%rip), %rdx     # 0x20601a
movl $0x2b0, %ecx            # imm = 0x2B0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x39b4(%rsp)
jmp 0x14f97a
movq 0x3990(%rsp), %rax
movl 0x908(%rax), %ecx
movq 0x3980(%rsp), %rax
movl %ecx, 0xa8(%rax)
movq 0x3980(%rsp), %rax
movslq 0xa8(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, %rcx
movq 0x3980(%rsp), %rax
movq %rcx, 0xb0(%rax)
movq 0x3980(%rsp), %rax
cmpq $0x0, 0xb0(%rax)
jne 0x14efed
movq 0x3980(%rsp), %rax
movslq 0xa8(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x213c(%rsp)
leaq 0x1930(%rsp), %rdi
movl 0x213c(%rsp), %ecx
leaq 0x83066(%rip), %rsi     # 0x1d2004
leaq 0xb7094(%rip), %rdx     # 0x206039
movb $0x0, %al
callq 0x5b9c0
movq 0x3980(%rsp), %rdi
addq $0xea, %rdi
leaq 0x1930(%rsp), %r8
leaq 0x8306a(%rip), %rsi     # 0x1d2034
leaq 0xb7049(%rip), %rdx     # 0x20601a
movl $0x2b3, %ecx            # imm = 0x2B3
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x39b4(%rsp)
jmp 0x14f97a
movl $0x0, 0x396c(%rsp)
movl 0x396c(%rsp), %eax
movq 0x3980(%rsp), %rcx
cmpl 0xa8(%rcx), %eax
jge 0x14f05a
movq 0x3990(%rsp), %rax
movq 0x910(%rax), %rax
movslq 0x396c(%rsp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movq 0x3980(%rsp), %rax
movq 0xb0(%rax), %rax
movslq 0x396c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x396c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x396c(%rsp)
jmp 0x14eff8
movl $0x0, 0x397c(%rsp)
movl 0x397c(%rsp), %eax
movq 0x3980(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x14f96f
movq 0x3990(%rsp), %rax
movq 0x900(%rax), %rax
movslq 0x397c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x3980(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x397c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x3980(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x397c(%rsp), %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x3, %rdi
movq 0x3980(%rsp), %rax
movslq 0x9c(%rax), %rax
imulq %rax, %rdi
movq 0x3980(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x397c(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
imulq %rax, %rdi
callq 0x8460
movq %rax, %rdx
movq 0x3980(%rsp), %rax
movq 0xd0(%rax), %rax
movslq 0x397c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x3980(%rsp), %rax
movq 0xd0(%rax), %rax
movslq 0x397c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x14f1fe
movq 0x3980(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x397c(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x3, %rax
movq 0x3980(%rsp), %rcx
movslq 0x9c(%rcx), %rcx
imulq %rcx, %rax
movq 0x3980(%rsp), %rcx
movq 0x20(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq %rcx, %rax
movl %eax, 0x192c(%rsp)
leaq 0x1120(%rsp), %rdi
movl 0x192c(%rsp), %ecx
leaq 0x82e55(%rip), %rsi     # 0x1d2004
leaq 0xb6e8a(%rip), %rdx     # 0x206040
movb $0x0, %al
callq 0x5b9c0
movq 0x3980(%rsp), %rdi
addq $0xea, %rdi
leaq 0x1120(%rsp), %r8
leaq 0x82e59(%rip), %rsi     # 0x1d2034
leaq 0xb6e38(%rip), %rdx     # 0x20601a
movl $0x2c4, %ecx            # imm = 0x2C4
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x39b4(%rsp)
jmp 0x14f97a
movq 0x3980(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x397c(%rsp), %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x3, %rdi
movq 0x3980(%rsp), %rax
movslq 0x9c(%rax), %rax
imulq %rax, %rdi
movq 0x3980(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x397c(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
imulq %rax, %rdi
callq 0x8460
movq %rax, %rdx
movq 0x3980(%rsp), %rax
movq 0xd8(%rax), %rax
movslq 0x397c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x3980(%rsp), %rax
movq 0xd8(%rax), %rax
movslq 0x397c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x14f34b
movq 0x3980(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x397c(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x3, %rax
movq 0x3980(%rsp), %rcx
movslq 0x9c(%rcx), %rcx
imulq %rcx, %rax
movq 0x3980(%rsp), %rcx
movq 0x20(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq %rcx, %rax
movl %eax, 0x111c(%rsp)
leaq 0x910(%rsp), %rdi
movl 0x111c(%rsp), %ecx
leaq 0x82d08(%rip), %rsi     # 0x1d2004
leaq 0xb6d4f(%rip), %rdx     # 0x206052
movb $0x0, %al
callq 0x5b9c0
movq 0x3980(%rsp), %rdi
addq $0xea, %rdi
leaq 0x910(%rsp), %r8
leaq 0x82d0c(%rip), %rsi     # 0x1d2034
leaq 0xb6ceb(%rip), %rdx     # 0x20601a
movl $0x2c5, %ecx            # imm = 0x2C5
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x39b4(%rsp)
jmp 0x14f97a
movq 0x3980(%rsp), %rax
movl 0x9c(%rax), %eax
shll %eax
addl $0x1, %eax
movl %eax, 0x3964(%rsp)
callq 0x2edc0
movl %eax, %esi
leaq 0x8d0(%rsp), %rdi
callq 0x2ef50
leaq 0x8b8(%rsp), %rdi
callq 0x2f070
movl $0x0, 0x3978(%rsp)
movl 0x3978(%rsp), %eax
movq 0x3980(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x14f764
movl 0x3978(%rsp), %eax
movl %eax, 0x3974(%rsp)
movl 0x3974(%rsp), %eax
movq 0x3980(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x14f74c
movl 0x3978(%rsp), %eax
cmpl 0x3974(%rsp), %eax
jg 0x14f44d
movl 0x3974(%rsp), %eax
movq 0x3980(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x3978(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x3978(%rsp), %eax
movl 0x3978(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x18(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
jmp 0x14f4a1
movl 0x3978(%rsp), %eax
movq 0x3980(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
imull 0x3974(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x3974(%rsp), %eax
movl 0x3974(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x3970(%rsp)
movq 0x3980(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x397c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x3970(%rsp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x1, %eax
jne 0x14f64e
movl $0x0, 0x396c(%rsp)
movl 0x396c(%rsp), %eax
movq 0x3990(%rsp), %rcx
movq 0x900(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x14f649
movq 0x3990(%rsp), %rax
movq %rax, 0x858(%rsp)
movl 0x3964(%rsp), %eax
movl %eax, 0x860(%rsp)
movq 0x3980(%rsp), %rax
movq %rax, 0x868(%rsp)
movl 0x397c(%rsp), %eax
movl %eax, 0x870(%rsp)
movq 0x39a8(%rsp), %rax
movq %rax, 0x878(%rsp)
movq 0x39a0(%rsp), %rax
movq %rax, 0x880(%rsp)
movq 0x3998(%rsp), %rax
movq %rax, 0x888(%rsp)
movq 0x3988(%rsp), %rax
movq %rax, 0x890(%rsp)
movl 0x3978(%rsp), %eax
movl %eax, 0x898(%rsp)
movl 0x3974(%rsp), %eax
movl %eax, 0x89c(%rsp)
movl 0x396c(%rsp), %eax
movl %eax, 0x8a0(%rsp)
leaq 0x8a8(%rsp), %rdi
leaq 0x8d0(%rsp), %rsi
leaq 0x858(%rsp), %rdx
callq 0x14fb20
jmp 0x14f5d0
leaq 0x8b8(%rsp), %rdi
leaq 0x8a8(%rsp), %rsi
callq 0x2f080
jmp 0x14f5e7
leaq 0x8a8(%rsp), %rdi
callq 0x2f0b0
movl 0x396c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x396c(%rsp)
jmp 0x14f4e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x850(%rsp)
movl %eax, 0x84c(%rsp)
jmp 0x14f953
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x850(%rsp)
movl %eax, 0x84c(%rsp)
leaq 0x8a8(%rsp), %rdi
callq 0x2f0b0
jmp 0x14f953
jmp 0x14f734
movl $0x0, 0x396c(%rsp)
movl 0x396c(%rsp), %eax
movq 0x3990(%rsp), %rcx
movq 0x900(%rcx), %rcx
movslq 0x397c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x14f732
movl $0x0, 0x3968(%rsp)
movl 0x3968(%rsp), %eax
movq 0x3980(%rsp), %rcx
cmpl 0x9c(%rcx), %eax
jge 0x14f71a
movq 0x3980(%rsp), %rax
movq 0xd0(%rax), %rax
movslq 0x397c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x396c(%rsp), %ecx
movq 0x3980(%rsp), %rdx
movq 0x20(%rdx), %rdx
movslq 0x397c(%rsp), %rsi
imull (%rdx,%rsi,4), %ecx
addl 0x3970(%rsp), %ecx
movq 0x3980(%rsp), %rdx
imull 0x9c(%rdx), %ecx
addl 0x3968(%rsp), %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x3968(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3968(%rsp)
jmp 0x14f68b
jmp 0x14f71c
movl 0x396c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x396c(%rsp)
jmp 0x14f659
jmp 0x14f734
jmp 0x14f736
movl 0x3974(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3974(%rsp)
jmp 0x14f3c3
jmp 0x14f74e
movl 0x3978(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3978(%rsp)
jmp 0x14f391
leaq 0x8b8(%rsp), %rax
movq %rax, 0x840(%rsp)
movq 0x840(%rsp), %rdi
callq 0x2f0c0
movq %rax, 0x838(%rsp)
movq 0x840(%rsp), %rdi
callq 0x2f0f0
movq %rax, 0x830(%rsp)
leaq 0x838(%rsp), %rdi
leaq 0x830(%rsp), %rsi
callq 0x2f120
testb $0x1, %al
jne 0x14f7b9
jmp 0x14f816
leaq 0x838(%rsp), %rdi
callq 0x2f160
movq %rax, 0x828(%rsp)
movq 0x828(%rsp), %rdi
callq 0x2f170
movl %eax, 0x10(%rsp)
jmp 0x14f7e1
movl 0x10(%rsp), %eax
cmpl $0x0, %eax
je 0x14f805
movl $0x1, 0x39b4(%rsp)
movl $0x1, 0x824(%rsp)
jmp 0x14f912
jmp 0x14f807
leaq 0x838(%rsp), %rdi
callq 0x2f1f0
jmp 0x14f79e
leaq 0x8b8(%rsp), %rdi
callq 0x2f210
movq 0x3980(%rsp), %r9
movq 0xb0(%r9), %rdi
movq 0xa0(%r9), %rax
movslq 0x397c(%rsp), %r8
movl (%rax,%r8,4), %esi
movq 0xd0(%r9), %rax
movq (%rax,%r8,8), %rdx
movq 0x20(%r9), %rax
movl (%rax,%r8,4), %ecx
movl 0x9c(%r9), %eax
imull %eax, %ecx
movq 0xd8(%r9), %rax
movq (%rax,%r8,8), %r8
addq $0xea, %r9
movq %rsp, %rax
movq %r9, (%rax)
movl $0x1, %r9d
callq 0x1cf90
movl %eax, 0xc(%rsp)
jmp 0x14f88b
movl 0xc(%rsp), %eax
cmpl $0x1, %eax
jne 0x14f907
movq 0x3980(%rsp), %rcx
addq $0xea, %rcx
leaq 0x82b2e(%rip), %rsi     # 0x1d23d8
leaq 0xb67b5(%rip), %rdx     # 0x206066
xorl %eax, %eax
leaq 0x20(%rsp), %rdi
callq 0x5b9c0
jmp 0x14f8bf
movq 0x3980(%rsp), %rdi
addq $0xea, %rdi
leaq 0x8275f(%rip), %rsi     # 0x1d2034
leaq 0xb673e(%rip), %rdx     # 0x20601a
xorl %eax, %eax
movl $0x337, %ecx            # imm = 0x337
leaq 0x20(%rsp), %r8
callq 0x5b9c0
jmp 0x14f8ef
movl $0x1, 0x39b4(%rsp)
movl $0x1, 0x824(%rsp)
jmp 0x14f912
movl $0x0, 0x824(%rsp)
leaq 0x8b8(%rsp), %rdi
callq 0x2f230
leaq 0x8d0(%rsp), %rdi
callq 0x2f290
movl 0x824(%rsp), %eax
testl %eax, %eax
je 0x14f93b
jmp 0x14f939
jmp 0x14f97a
jmp 0x14f93d
movl 0x397c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x397c(%rsp)
jmp 0x14f065
leaq 0x8b8(%rsp), %rdi
callq 0x2f230
leaq 0x8d0(%rsp), %rdi
callq 0x2f290
jmp 0x14f989
movl $0x0, 0x39b4(%rsp)
movl 0x39b4(%rsp), %eax
addq $0x39b8, %rsp           # imm = 0x39B8
retq
movq 0x850(%rsp), %rdi
callq 0x8640
nopw %cs:(%rax,%rax)