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

  int index_ct;
  int index_md;
  int index_ic1_ic2;

  phr->md_size = ppt->md_size;
  if (ppt->has_scalars == _TRUE_)
    phr->index_md_scalars = ppt->index_md_scalars;

  class_alloc(phr->ic_size,
              sizeof(int)*phr->md_size,
              phr->error_message);

  class_alloc(phr->ic_ic_size,
              sizeof(int)*phr->md_size,
              phr->error_message);

  class_alloc(phr->is_non_zero,
              sizeof(short *)*phr->md_size,
              phr->error_message);

  for (index_md=0; index_md < phr->md_size; index_md++) {
    phr->ic_size[index_md] = ppm->ic_size[index_md];
    phr->ic_ic_size[index_md] = ppm->ic_ic_size[index_md];
    class_alloc(phr->is_non_zero[index_md],
                sizeof(short)*phr->ic_ic_size[index_md],
                phr->error_message);
    for (index_ic1_ic2=0; index_ic1_ic2 < phr->ic_ic_size[index_md]; index_ic1_ic2++)
      phr->is_non_zero[index_md][index_ic1_ic2] = ppm->is_non_zero[index_md][index_ic1_ic2];
  }

  if (ppt->has_cls == _TRUE_) {

    /* types of C_l's relevant for both scalars and tensors: TT, EE, TE */

    index_ct=0;

    if (ppt->has_cl_cmb_temperature == _TRUE_) {
      phr->has_tt = _TRUE_;
      phr->index_ct_tt=index_ct;
      index_ct++;
    }
    else {
      phr->has_tt = _FALSE_;
    }

    if (ppt->has_cl_cmb_polarization == _TRUE_) {
      phr->has_ee = _TRUE_;
      phr->index_ct_ee=index_ct;
      index_ct++;
    }
    else {
      phr->has_ee = _FALSE_;
    }

    if ((ppt->has_cl_cmb_temperature == _TRUE_) &&
        (ppt->has_cl_cmb_polarization == _TRUE_)) {
      phr->has_te = _TRUE_;
      phr->index_ct_te=index_ct;
      index_ct++;
    }
    else {
      phr->has_te = _FALSE_;
    }

    if (ppt->has_cl_cmb_polarization == _TRUE_) {
      phr->has_bb = _TRUE_;
      phr->index_ct_bb=index_ct;
      index_ct++;
    }
    else {
      phr->has_bb = _FALSE_;
    }

    /* types of C_l's relevant only for scalars: phi-phi, T-phi, E-phi, d-d, T-d */

    if ((ppt->has_cl_cmb_lensing_potential == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
      phr->has_pp = _TRUE_;
      phr->index_ct_pp=index_ct;
      index_ct++;
    }
    else {
      phr->has_pp = _FALSE_;
    }

    if ((ppt->has_cl_cmb_temperature == _TRUE_) && (ppt->has_cl_cmb_lensing_potential == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
      phr->has_tp = _TRUE_;
      phr->index_ct_tp=index_ct;
      index_ct++;
    }
    else {
      phr->has_tp = _FALSE_;
    }

    phr->ct_size = index_ct;

    if ((ppt->has_cl_cmb_polarization == _TRUE_) && (ppt->has_cl_cmb_lensing_potential == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
      phr->has_ep = _TRUE_;
      phr->index_ct_ep=index_ct;
      index_ct++;
    }
    else {
      phr->has_ep = _FALSE_;
    }

    if ((ppt->has_scalars == _TRUE_) &&
        ((ppt->has_cl_number_count == _TRUE_) || (ppt->has_cl_lensing_potential == _TRUE_)))
      phr->d_size=ppt->selection_num;
    else
      phr->d_size=0;

    if ((ppt->has_cl_number_count == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
      phr->has_dd = _TRUE_;
      phr->index_ct_dd=index_ct;
      index_ct+=(phr->d_size*(phr->d_size+1)-(phr->d_size-phr->non_diag)*(phr->d_size-1-phr->non_diag))/2;
    }
    else {
      phr->has_dd = _FALSE_;
    }

    /* the computation of C_l^Td would require a very good sampling of
       transfer functions over a wide range, and a huge computation
       time. In the current version, we prefer to switch it off, rather
       than either slowing down the code considerably, or producing
       very inaccurate spectra.

       if ((ppt->has_cl_cmb_temperature == _TRUE_) && (ppt->has_cl_number_count == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
       phr->has_td = _TRUE_;
       phr->index_ct_td=index_ct;
       index_ct+=phr->d_size;
       }
       else {
       phr->has_td = _FALSE_;
       }
    */
    phr->has_td = _FALSE_;

    if ((ppt->has_cl_cmb_lensing_potential == _TRUE_) && (ppt->has_cl_number_count == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
      phr->has_pd = _TRUE_;
      phr->index_ct_pd=index_ct;
      index_ct+=phr->d_size;
    }
    else {
      phr->has_pd = _FALSE_;
    }

    if ((ppt->has_cl_lensing_potential == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
      phr->has_ll = _TRUE_;
      phr->index_ct_ll=index_ct;
      index_ct+=(phr->d_size*(phr->d_size+1)-(phr->d_size-phr->non_diag)*(phr->d_size-1-phr->non_diag))/2;
    }
    else {
      phr->has_ll = _FALSE_;
    }

    /* the computation of C_l^Tl would require a very good sampling of
       transfer functions over a wide range, and a huge computation
       time. In the current version, we prefer to switch it off, rather
       than either slowing down the code considerably, or producing
       very inaccurate spectra.

       if ((ppt->has_cl_cmb_temperature == _TRUE_) && (ppt->has_cl_lensing_potential == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
       phr->has_tl = _TRUE_;
       phr->index_ct_tl=index_ct;
       index_ct+=phr->d_size;
       }
       else {
       phr->has_tl = _FALSE_;
       }
    */
    phr->has_tl = _FALSE_;

    if ((ppt->has_cl_number_count == _TRUE_) && (ppt->has_cl_lensing_potential == _TRUE_) && (ppt->has_scalars == _TRUE_)) {
      phr->has_dl = _TRUE_;
      phr->index_ct_dl=index_ct;
      index_ct += phr->d_size*phr->d_size - (phr->d_size-phr->non_diag)*(phr->d_size-1-phr->non_diag);
    }
    else {
      phr->has_dl = _FALSE_;
    }

    phr->ct_size = index_ct;

    /* infer from input quantities the l_max for each mode and type,
       l_max_ct[index_md][index_type].  Maximize it over index_ct, and
       then over index_md. */

    class_alloc(phr->l_max,sizeof(int*)*phr->md_size,phr->error_message);
    class_alloc(phr->l_max_ct,sizeof(int*)*phr->md_size,phr->error_message);
    for (index_md=0; index_md<phr->md_size; index_md++) {
      class_calloc(phr->l_max_ct[index_md],phr->ct_size,sizeof(int),phr->error_message);
    }

    if (ppt->has_scalars == _TRUE_) {

      /* spectra computed up to l_scalar_max */

      if (phr->has_tt == _TRUE_) phr->l_max_ct[ppt->index_md_scalars][phr->index_ct_tt] = ppt->l_scalar_max;
      if (phr->has_ee == _TRUE_) phr->l_max_ct[ppt->index_md_scalars][phr->index_ct_ee] = ppt->l_scalar_max;
      if (phr->has_te == _TRUE_) phr->l_max_ct[ppt->index_md_scalars][phr->index_ct_te] = ppt->l_scalar_max;
      if (phr->has_pp == _TRUE_) phr->l_max_ct[ppt->index_md_scalars][phr->index_ct_pp] = ppt->l_scalar_max;
      if (phr->has_tp == _TRUE_) phr->l_max_ct[ppt->index_md_scalars][phr->index_ct_tp] = ppt->l_scalar_max;
      if (phr->has_ep == _TRUE_) phr->l_max_ct[ppt->index_md_scalars][phr->index_ct_ep] = ppt->l_scalar_max;

      /* spectra computed up to l_lss_max */

      if (phr->has_dd == _TRUE_)
        for (index_ct=phr->index_ct_dd;
             index_ct<phr->index_ct_dd+(phr->d_size*(phr->d_size+1)-(phr->d_size-phr->non_diag)*(phr->d_size-1-phr->non_diag))/2;
             index_ct++)
          phr->l_max_ct[ppt->index_md_scalars][index_ct] = ppt->l_lss_max;

      if (phr->has_td == _TRUE_)
        for (index_ct=phr->index_ct_td;
             index_ct<phr->index_ct_td+phr->d_size;
             index_ct++)
          phr->l_max_ct[ppt->index_md_scalars][index_ct] = MIN(ppt->l_scalar_max,ppt->l_lss_max);

      if (phr->has_pd == _TRUE_)
        for (index_ct=phr->index_ct_pd;
             index_ct<phr->index_ct_pd+phr->d_size;
             index_ct++)
          phr->l_max_ct[ppt->index_md_scalars][index_ct] = MIN(ppt->l_scalar_max,ppt->l_lss_max);

      if (phr->has_ll == _TRUE_)
        for (index_ct=phr->index_ct_ll;
             index_ct<phr->index_ct_ll+(phr->d_size*(phr->d_size+1)-(phr->d_size-phr->non_diag)*(phr->d_size-1-phr->non_diag))/2;
             index_ct++)
          phr->l_max_ct[ppt->index_md_scalars][index_ct] = ppt->l_lss_max;

      if (phr->has_tl == _TRUE_)
        for (index_ct=phr->index_ct_tl;
             index_ct<phr->index_ct_tl+phr->d_size;
             index_ct++)
          phr->l_max_ct[ppt->index_md_scalars][index_ct] = MIN(ppt->l_scalar_max,ppt->l_lss_max);

      if (phr->has_dl == _TRUE_)
        for (index_ct=phr->index_ct_dl;
             index_ct < phr->index_ct_dl+(phr->d_size*phr->d_size - (phr->d_size-phr->non_diag)*(phr->d_size-1-phr->non_diag));
             index_ct++)
          phr->l_max_ct[ppt->index_md_scalars][index_ct] = ppt->l_lss_max;

    }
    if (ppt->has_tensors == _TRUE_) {

      /* spectra computed up to l_tensor_max */

      if (phr->has_tt == _TRUE_) phr->l_max_ct[ppt->index_md_tensors][phr->index_ct_tt] = ppt->l_tensor_max;
      if (phr->has_ee == _TRUE_) phr->l_max_ct[ppt->index_md_tensors][phr->index_ct_ee] = ppt->l_tensor_max;
      if (phr->has_te == _TRUE_) phr->l_max_ct[ppt->index_md_tensors][phr->index_ct_te] = ppt->l_tensor_max;
      if (phr->has_bb == _TRUE_) phr->l_max_ct[ppt->index_md_tensors][phr->index_ct_bb] = ppt->l_tensor_max;
    }

    /* maximizations */
    phr->l_max_tot = 0.;
    for (index_md=0; index_md < phr->md_size; index_md++) {
      phr->l_max[index_md] = 0.;
      for (index_ct=0.; index_ct<phr->ct_size; index_ct++)
        phr->l_max[index_md] = MAX(phr->l_max[index_md],phr->l_max_ct[index_md][index_ct]);
      phr->l_max_tot = MAX(phr->l_max_tot,phr->l_max[index_md]);
    }
  }

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r8, %rbx
movq %rcx, %r12
movq %rsi, %r14
movl 0x854(%rsi), %r15d
movslq %r15d, %rbp
movl %ebp, 0x10(%r8)
cmpw $0x1, 0xe(%rsi)
jne 0xb347a
movl 0x848(%r14), %eax
movl %eax, 0x14(%rbx)
leaq (,%rbp,4), %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0xb35be
movq %r13, %rdi
callq 0x8460
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xb3604
movq %rax, %r13
shlq $0x3, %rbp
movq %rbp, %rdi
callq 0x8460
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xb364a
testl %r15d, %r15d
jle 0xb355c
movq %rax, %rbp
movq %r14, 0x10(%rsp)
xorl %r14d, %r14d
movq 0x280(%r12), %rax
movl (%rax,%r14,4), %eax
movq 0x18(%rbx), %rcx
movl %eax, (%rcx,%r14,4)
movq 0x288(%r12), %rax
movslq (%rax,%r14,4), %rdi
movl %edi, (%r13,%r14,4)
addq %rdi, %rdi
callq 0x8460
movq %rax, (%rbp,%r14,8)
movq 0x20(%rbx), %r13
movq 0x28(%rbx), %rbp
movq (%rbp,%r14,8), %rax
movl (%r13,%r14,4), %ecx
testq %rax, %rax
je 0xb3690
testl %ecx, %ecx
jle 0xb354b
movq 0x2b0(%r12), %rdx
movq (%rdx,%r14,8), %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
movw %di, (%rax,%rsi,2)
incq %rsi
cmpq %rsi, %rcx
jne 0xb353b
incq %r14
movslq 0x10(%rbx), %r15
cmpq %r15, %r14
jl 0xb34dc
movq 0x10(%rsp), %r14
cmpw $0x1, 0xc(%r14)
jne 0xb3e31
movzwl 0x28(%r14), %ecx
cmpw $0x1, %cx
jne 0xb36d1
movl $0x1, 0x30(%rbx)
movl $0x0, 0x64(%rbx)
movl $0x1, %r8d
cmpw $0x1, 0x2a(%r14)
jne 0xb3715
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x34(%rbx)
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, 0x68(%rbx)
movl $0x3, %r13d
jmp 0xb36fb
shll $0x2, %r15d
leaq 0x3aa3b(%rip), %rsi     # 0xee004
leaq 0x6e3d2(%rip), %rdx     # 0x1219a2
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0x3aa44(%rip), %rsi     # 0xee034
leaq 0x6e3b8(%rip), %rdx     # 0x1219af
movq %rbx, %rdi
movl $0x18c, %ecx            # imm = 0x18C
jmp 0xb3e74
shll $0x2, %r15d
leaq 0x3a9f5(%rip), %rsi     # 0xee004
leaq 0x6e3aa(%rip), %rdx     # 0x1219c0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0x3a9fe(%rip), %rsi     # 0xee034
leaq 0x6e372(%rip), %rdx     # 0x1219af
movq %rbx, %rdi
movl $0x190, %ecx            # imm = 0x190
jmp 0xb3e74
shll $0x3, %r15d
leaq 0x3a9af(%rip), %rsi     # 0xee004
leaq 0x6e374(%rip), %rdx     # 0x1219d0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0x3a9b8(%rip), %rsi     # 0xee034
leaq 0x6e32c(%rip), %rdx     # 0x1219af
movq %rbx, %rdi
movl $0x194, %ecx            # imm = 0x194
jmp 0xb3e74
addl %ecx, %ecx
leaq 0x3a96b(%rip), %rsi     # 0xee004
leaq 0x6e341(%rip), %rdx     # 0x1219e1
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0x3a977(%rip), %rsi     # 0xee034
leaq 0x6e2eb(%rip), %rdx     # 0x1219af
movq %rbx, %rdi
movl $0x19b, %ecx            # imm = 0x19B
jmp 0xb3e74
movl $0x0, 0x30(%rbx)
xorl %r8d, %r8d
cmpw $0x1, 0x2a(%r14)
jne 0xb3715
movq $0x1, 0x34(%rbx)
movl $0x0, 0x68(%rbx)
movl $0x1, %r13d
xorl %r8d, %r8d
movl $0x1, 0x3c(%rbx)
movl %r13d, 0x70(%rbx)
incl %r13d
movb $0x1, %dl
movl $0x1, 0xc(%rsp)
jmp 0xb3731
movq $0x0, 0x34(%rbx)
movl $0x0, 0x3c(%rbx)
movl $0x0, 0xc(%rsp)
xorl %edx, %edx
movl %r8d, %r13d
movzwl 0x2c(%r14), %eax
cmpw $0x1, %ax
movl %r8d, 0x18(%rsp)
je 0xb375e
xorl %ecx, %ecx
movl %ecx, 0x40(%rbx)
movzwl 0xe(%r14), %esi
movl %ecx, 0x44(%rbx)
leaq 0x9c(%rbx), %rbp
movl %r13d, 0x9c(%rbx)
jmp 0xb37d6
movzwl 0xe(%r14), %esi
cmpw $0x1, %si
jne 0xb37a7
leal 0x1(%r13), %edi
movl $0x1, 0x40(%rbx)
movl %r13d, 0x74(%rbx)
cmpw $0x1, %cx
jne 0xb37b0
movl $0x1, 0x44(%rbx)
movl %edi, 0x78(%rbx)
addl $0x2, %r13d
leaq 0x9c(%rbx), %rbp
movl %r13d, 0x9c(%rbx)
testb %dl, %dl
jne 0xb37f2
movl $0x0, 0x48(%rbx)
jmp 0xb3800
movl $0x0, 0x40(%rbx)
jmp 0xb37b3
movl %edi, %r13d
cmpw $0x1, %ax
setne %cl
movl $0x0, 0x44(%rbx)
leaq 0x9c(%rbx), %rbp
movl %r13d, 0x9c(%rbx)
xorb $0x1, %dl
orb %cl, %dl
je 0xb37e8
movl $0x0, 0x48(%rbx)
cmpw $0x1, %si
je 0xb3800
jmp 0xb387e
cmpw $0x1, %si
jne 0xb3877
movl $0x1, 0x48(%rbx)
movl %r13d, 0x7c(%rbx)
incl %r13d
cmpw $0x1, 0x30(%r14)
jne 0xb384b
movl 0x64(%r14), %ecx
movl %ecx, 0x98(%rbx)
movl $0x1, 0x4c(%rbx)
movl %r13d, 0x80(%rbx)
leal 0x1(%rcx), %edx
imull %ecx, %edx
movl (%rbx), %esi
movl %esi, %edi
subl %ecx, %edi
notl %esi
addl %ecx, %esi
imull %edi, %esi
addl %edx, %esi
movl %esi, %edi
shrl $0x1f, %edi
addl %esi, %edi
sarl %edi
addl %r13d, %edi
xorl %r8d, %r8d
xorl %edx, %edx
movl %edi, %r13d
jmp 0xb389d
cmpw $0x1, 0x2e(%r14)
jne 0xb3864
movl 0x64(%r14), %ecx
movl %ecx, 0x98(%rbx)
movb $0x1, %dl
xorl %r8d, %r8d
jmp 0xb3896
movl $0x0, 0x98(%rbx)
movb $0x1, %dl
xorl %r8d, %r8d
xorl %ecx, %ecx
jmp 0xb3896
movl $0x0, 0x48(%rbx)
movl $0x0, 0x98(%rbx)
cmpw $0x1, 0x30(%r14)
setne %dl
xorl %ecx, %ecx
movb $0x1, %r8b
movl $0x0, 0x4c(%rbx)
cmpw $0x1, %ax
setne %al
movl $0x0, 0x50(%rbx)
orb %dl, %al
testb $0x1, %al
je 0xb38cb
movl $0x0, 0x54(%rbx)
cmpw $0x1, 0x2e(%r14)
setne %al
movl %r8d, %esi
orb %al, %sil
je 0xb38fd
jmp 0xb3933
testb %r8b, %r8b
je 0xb38e2
movl $0x0, 0x54(%rbx)
cmpw $0x1, 0x2e(%r14)
setne %al
jmp 0xb3933
movl $0x1, 0x54(%rbx)
movl %r13d, 0x88(%rbx)
addl %ecx, %r13d
movb $0x1, %al
cmpw $0x1, 0x2e(%r14)
jne 0xb3933
movl $0x1, 0x58(%rbx)
movl %r13d, 0x8c(%rbx)
leal 0x1(%rcx), %eax
imull %ecx, %eax
movl (%rbx), %esi
movl %esi, %edi
subl %ecx, %edi
notl %esi
addl %ecx, %esi
imull %edi, %esi
addl %eax, %esi
movl %esi, %edi
shrl $0x1f, %edi
addl %esi, %edi
sarl %edi
addl %r13d, %edi
xorl %eax, %eax
movl %edi, %r13d
jmp 0xb393a
movl $0x0, 0x58(%rbx)
movl $0x0, 0x5c(%rbx)
orb %al, %dl
orb %r8b, %dl
xorl %eax, %eax
testb $0x1, %dl
movl %r8d, 0x1c(%rsp)
jne 0xb3978
movl %r13d, 0x94(%rbx)
movl %ecx, %eax
imull %ecx, %eax
movl (%rbx), %edx
movl %edx, %esi
subl %ecx, %esi
notl %edx
addl %ecx, %edx
imull %esi, %edx
addl %eax, %edx
addl %r13d, %edx
movl $0x1, %eax
movl %edx, %r13d
movl %eax, 0x60(%rbx)
movl %r13d, 0x9c(%rbx)
movslq %r15d, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x8460
movq %rax, 0xc0(%rbx)
testq %rax, %rax
je 0xb3b1e
movq %r12, %rdi
callq 0x8460
movq %rax, 0xb8(%rbx)
testq %rax, %rax
je 0xb3b64
movq %rax, %r12
movq %r14, 0x10(%rsp)
testl %r15d, %r15d
jle 0xb39fa
movslq %r13d, %r13
movl %r15d, %r14d
xorl %r15d, %r15d
movl $0x4, %esi
movq %r13, %rdi
callq 0x8250
movq %rax, (%r12,%r15,8)
movq 0xb8(%rbx), %r12
cmpq $0x0, (%r12,%r15,8)
je 0xb3e35
incq %r15
cmpq %r15, %r14
jne 0xb39cf
cmpb $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %r9
jne 0xb3d4b
cmpl $0x0, 0x18(%rsp)
movl 0xc(%rsp), %eax
je 0xb3a2e
movl 0x48(%r9), %eax
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x64(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
movl 0x34(%rbx), %eax
cmpl $0x1, %eax
jne 0xb3a49
movl 0x48(%r9), %eax
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x68(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x38(%rbx)
jne 0xb3a65
movl 0x48(%r9), %eax
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x6c(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x40(%rbx)
jne 0xb3a81
movl 0x48(%r9), %eax
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x74(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x44(%rbx)
jne 0xb3a9d
movl 0x48(%r9), %eax
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x78(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x48(%rbx)
jne 0xb3ab9
movl 0x48(%r9), %eax
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x7c(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x4c(%rbx)
jne 0xb3baa
movl 0x80(%rbx), %ecx
movslq %ecx, %rax
movl (%rbx), %edx
movl 0x98(%rbx), %esi
leal 0x1(%rsi), %edi
imull %esi, %edi
movl %edx, %r8d
subl %esi, %r8d
notl %edx
addl %esi, %edx
imull %r8d, %edx
addl %edi, %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
addl %ecx, %esi
movslq %esi, %rcx
cmpq %rcx, %rax
jge 0xb3baa
movl 0x54(%r9), %ecx
movslq 0x848(%r9), %rdx
movq (%r12,%rdx,8), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
movl 0x80(%rbx), %ecx
jmp 0xb3acc
shll $0x3, %r15d
leaq 0x3a4db(%rip), %rsi     # 0xee004
leaq 0x6decc(%rip), %rdx     # 0x1219fc
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0x3a4e4(%rip), %rsi     # 0xee034
leaq 0x6de58(%rip), %rdx     # 0x1219af
movq %rbx, %rdi
movl $0x23c, %ecx            # imm = 0x23C
jmp 0xb3e74
shll $0x3, %r15d
leaq 0x3a495(%rip), %rsi     # 0xee004
leaq 0x6de91(%rip), %rdx     # 0x121a07
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0x3a49e(%rip), %rsi     # 0xee034
leaq 0x6de12(%rip), %rdx     # 0x1219af
movq %rbx, %rdi
movl $0x23d, %ecx            # imm = 0x23D
jmp 0xb3e74
cmpl $0x1, 0x50(%rbx)
jne 0xb3bf4
cmpl $0x0, 0x98(%rbx)
jle 0xb3bf4
movslq 0x84(%rbx), %rax
movl 0x48(%r9), %ecx
movl 0x54(%r9), %edx
cmpl %edx, %ecx
cmovll %ecx, %edx
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movl %edx, (%rcx,%rax,4)
incq %rax
movslq 0x84(%rbx), %rcx
movslq 0x98(%rbx), %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
jl 0xb3bc0
cmpl $0x1, 0x54(%rbx)
jne 0xb3c3e
cmpl $0x0, 0x98(%rbx)
jle 0xb3c3e
movslq 0x88(%rbx), %rax
movl 0x48(%r9), %ecx
movl 0x54(%r9), %edx
cmpl %edx, %ecx
cmovll %ecx, %edx
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movl %edx, (%rcx,%rax,4)
incq %rax
movslq 0x88(%rbx), %rcx
movslq 0x98(%rbx), %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
jl 0xb3c0a
cmpl $0x1, 0x58(%rbx)
jne 0xb3c9b
movl 0x8c(%rbx), %ecx
movslq %ecx, %rax
movl (%rbx), %edx
movl 0x98(%rbx), %esi
leal 0x1(%rsi), %edi
imull %esi, %edi
movl %edx, %r8d
subl %esi, %r8d
notl %edx
addl %esi, %edx
imull %r8d, %edx
addl %edi, %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
addl %ecx, %esi
movslq %esi, %rcx
cmpq %rcx, %rax
jge 0xb3c9b
movl 0x54(%r9), %ecx
movslq 0x848(%r9), %rdx
movq (%r12,%rdx,8), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
movl 0x8c(%rbx), %ecx
jmp 0xb3c4d
cmpl $0x1, 0x5c(%rbx)
jne 0xb3ce5
cmpl $0x0, 0x98(%rbx)
jle 0xb3ce5
movslq 0x90(%rbx), %rax
movl 0x48(%r9), %ecx
movl 0x54(%r9), %edx
cmpl %edx, %ecx
cmovll %ecx, %edx
movslq 0x848(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movl %edx, (%rcx,%rax,4)
incq %rax
movslq 0x90(%rbx), %rcx
movslq 0x98(%rbx), %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
jl 0xb3cb1
cmpl $0x1, 0x60(%rbx)
jne 0xb3d4b
movslq 0x94(%rbx), %rax
movl (%rbx), %ecx
movl 0x98(%rbx), %edx
movl %ecx, %esi
subl %edx, %esi
notl %ecx
addl %edx, %ecx
imull %edx, %edx
imull %esi, %ecx
addl %eax, %edx
addl %ecx, %edx
cmpl %edx, %eax
jge 0xb3d4b
movl 0x54(%r9), %ecx
movslq 0x848(%r9), %rdx
movq (%r12,%rdx,8), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
movl (%rbx), %edx
movl 0x98(%rbx), %esi
movl %edx, %edi
subl %esi, %edi
notl %edx
addl %esi, %edx
imull %esi, %esi
addl 0x94(%rbx), %esi
imull %edi, %edx
addl %edx, %esi
movslq %esi, %rdx
cmpq %rdx, %rax
jl 0xb3d14
cmpw $0x1, 0x12(%r9)
jne 0xb3dc3
cmpl $0x1, 0x30(%rbx)
jne 0xb3d6f
movl 0x50(%r9), %eax
movslq 0x84c(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x64(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x34(%rbx)
jne 0xb3d8b
movl 0x50(%r9), %eax
movslq 0x84c(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x68(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x38(%rbx)
jne 0xb3da7
movl 0x50(%r9), %eax
movslq 0x84c(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x6c(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x3c(%rbx)
jne 0xb3dc3
movl 0x50(%r9), %eax
movslq 0x84c(%r9), %rcx
movq (%r12,%rcx,8), %rcx
movslq 0x70(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
movl $0x0, 0xc8(%rbx)
cmpl $0x0, 0x10(%rbx)
jle 0xb3e31
movq 0xc0(%rbx), %rcx
xorl %edx, %edx
movl $0x0, (%rcx,%rdx,4)
cmpl $0x0, (%rbp)
movl $0x0, %eax
jle 0xb3e10
movq (%r12,%rdx,8), %rsi
xorl %eax, %eax
xorl %edi, %edi
movl (%rsi,%rdi,4), %r8d
cmpl %r8d, %eax
cmovlel %r8d, %eax
movl %eax, (%rcx,%rdx,4)
incq %rdi
movslq (%rbp), %r8
cmpq %r8, %rdi
jl 0xb3df6
movl 0xc8(%rbx), %esi
cmpl %eax, %esi
cmovgl %esi, %eax
movl %eax, 0xc8(%rbx)
incq %rdx
movslq 0x10(%rbx), %rsi
xorl %eax, %eax
cmpq %rsi, %rdx
jl 0xb3ddc
jmp 0xb3e83
xorl %eax, %eax
jmp 0xb3e83
leaq 0x3a1c8(%rip), %rsi     # 0xee004
leaq 0x6dbd2(%rip), %rdx     # 0x121a15
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x4, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0x3a1cf(%rip), %rsi     # 0xee034
leaq 0x6db43(%rip), %rdx     # 0x1219af
movq %rbx, %rdi
movl $0x23f, %ecx            # imm = 0x23F
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq