// File: /workspace/github_c_makefile_star2_O1/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 $0x808, %rsp            # imm = 0x808
movq %r8, %rbx
movq %rcx, %r12
movq %rsi, %r14
movslq 0x854(%rsi), %r15
movl %r15d, 0x10(%r8)
cmpw $0x1, 0xe(%rsi)
jne 0xb660f
movl 0x848(%r14), %eax
movl %eax, 0x14(%rbx)
leaq (,%r15,4), %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0xb6713
movq %r13, %rdi
callq 0x8460
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xb6757
leaq (,%r15,8), %rdi
callq 0x8460
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xb679b
movl 0x10(%rbx), %r15d
testl %r15d, %r15d
jle 0xb66ea
xorl %r13d, %r13d
movq 0x280(%r12), %rax
movl (%rax,%r13,4), %eax
movq 0x18(%rbx), %rcx
movl %eax, (%rcx,%r13,4)
movq 0x288(%r12), %rax
movslq (%rax,%r13,4), %rdi
movq 0x20(%rbx), %rax
movl %edi, (%rax,%r13,4)
addq %rdi, %rdi
callq 0x8460
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rax
movl (%rcx,%r13,4), %ecx
testq %rax, %rax
je 0xb67df
testl %ecx, %ecx
jle 0xb66de
movq 0x2b0(%r12), %rdx
movq (%rdx,%r13,8), %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
movw %di, (%rax,%rsi,2)
incq %rsi
cmpq %rsi, %rcx
jne 0xb66ce
incq %r13
movslq 0x10(%rbx), %r15
cmpq %r15, %r13
jl 0xb666b
cmpw $0x1, 0xc(%r14)
jne 0xb6f85
movzwl 0x28(%r14), %edx
cmpw $0x1, %dx
je 0xb681e
movl $0x0, 0x30(%rbx)
xorl %ebp, %ebp
jmp 0xb6831
shll $0x2, %r15d
leaq 0x3a8e6(%rip), %rsi     # 0xf1004
leaq 0x6e255(%rip), %rdx     # 0x12497a
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0x3a8f1(%rip), %rsi     # 0xf1034
leaq 0x6e23d(%rip), %rdx     # 0x124987
movq %rbx, %rdi
movl $0x18c, %ecx            # imm = 0x18C
jmp 0xb6fc6
shll $0x2, %r15d
leaq 0x3a8a2(%rip), %rsi     # 0xf1004
leaq 0x6e22f(%rip), %rdx     # 0x124998
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0x3a8ad(%rip), %rsi     # 0xf1034
leaq 0x6e1f9(%rip), %rdx     # 0x124987
movq %rbx, %rdi
movl $0x190, %ecx            # imm = 0x190
jmp 0xb6fc6
shll $0x3, %r15d
leaq 0x3a85e(%rip), %rsi     # 0xf1004
leaq 0x6e1fb(%rip), %rdx     # 0x1249a8
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0x3a869(%rip), %rsi     # 0xf1034
leaq 0x6e1b5(%rip), %rdx     # 0x124987
movq %rbx, %rdi
movl $0x194, %ecx            # imm = 0x194
jmp 0xb6fc6
addl %ecx, %ecx
leaq 0x3a81c(%rip), %rsi     # 0xf1004
leaq 0x6e1ca(%rip), %rdx     # 0x1249b9
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0x3a82a(%rip), %rsi     # 0xf1034
leaq 0x6e176(%rip), %rdx     # 0x124987
movq %rbx, %rdi
movl $0x19b, %ecx            # imm = 0x19B
jmp 0xb6fc6
movl $0x1, 0x30(%rbx)
movl $0x0, 0x64(%rbx)
movl $0x1, %ebp
movzwl 0x2a(%r14), %ecx
cmpw $0x1, %cx
je 0xb6845
movl $0x0, 0x34(%rbx)
jmp 0xb6851
movl $0x1, 0x34(%rbx)
movl %ebp, 0x68(%rbx)
incl %ebp
movl %ecx, %eax
xorl $0x1, %eax
movl %edx, %esi
xorl $0x1, %esi
orw %ax, %si
je 0xb6869
movl $0x0, 0x38(%rbx)
jmp 0xb6875
movl $0x1, 0x38(%rbx)
movl %ebp, 0x6c(%rbx)
incl %ebp
cmpw $0x1, %cx
je 0xb6884
movl $0x0, 0x3c(%rbx)
jmp 0xb6890
movl $0x1, 0x3c(%rbx)
movl %ebp, 0x70(%rbx)
incl %ebp
movzwl 0x2c(%r14), %eax
cmpw $0x1, %ax
jne 0xb68b1
cmpw $0x1, 0xe(%r14)
jne 0xb68b1
movl $0x1, 0x40(%rbx)
movl %ebp, 0x74(%rbx)
incl %ebp
jmp 0xb68b8
movl $0x0, 0x40(%rbx)
movl %eax, %esi
xorl $0x1, %esi
xorl $0x1, %edx
orw %si, %dx
jne 0xb68db
cmpw $0x1, 0xe(%r14)
jne 0xb68db
movl $0x1, 0x44(%rbx)
movl %ebp, 0x78(%rbx)
incl %ebp
jmp 0xb68e2
movl $0x0, 0x44(%rbx)
movl %eax, %edx
xorl $0x1, %edx
xorl $0x1, %ecx
movl %ebp, 0x9c(%rbx)
orw %dx, %cx
jne 0xb690b
cmpw $0x1, 0xe(%r14)
jne 0xb690b
movl $0x1, 0x48(%rbx)
movl %ebp, 0x7c(%rbx)
incl %ebp
jmp 0xb6912
movl $0x0, 0x48(%rbx)
movzwl 0xe(%r14), %r13d
xorl %ecx, %ecx
cmpw $0x1, %r13w
jne 0xb6934
cmpw $0x1, 0x30(%r14)
je 0xb6930
cmpw $0x1, 0x2e(%r14)
jne 0xb6934
movl 0x64(%r14), %ecx
movl %r13d, %edx
xorl $0x1, %edx
movl %ecx, 0x98(%rbx)
movl 0x30(%r14), %ecx
movl %ecx, %esi
xorl $0x1, %esi
orw %dx, %si
je 0xb6957
movl $0x0, 0x4c(%rbx)
jmp 0xb698d
movl $0x1, 0x4c(%rbx)
movl %ebp, 0x80(%rbx)
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 %esi, %ebp
movl $0x0, 0x50(%rbx)
cmpw $0x1, %r13w
jne 0xb69bc
cmpw $0x1, %ax
jne 0xb69bc
cmpw $0x1, %cx
jne 0xb69bc
movl $0x1, 0x54(%rbx)
movl %ebp, 0x88(%rbx)
addl 0x98(%rbx), %ebp
jmp 0xb69c3
movl $0x0, 0x54(%rbx)
movl %r13d, %edx
xorl $0x1, %edx
movzwl 0x2e(%r14), %eax
movl %eax, %esi
xorl $0x1, %esi
orw %dx, %si
je 0xb69e1
movl $0x0, 0x58(%rbx)
jmp 0xb6a17
movl $0x1, 0x58(%rbx)
movl %ebp, 0x8c(%rbx)
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 %esi, %ebp
movl $0x0, 0x5c(%rbx)
cmpw $0x1, %r13w
jne 0xb6a5a
cmpw $0x1, %cx
jne 0xb6a5a
cmpw $0x1, %ax
jne 0xb6a5a
movl $0x1, 0x60(%rbx)
movl %ebp, 0x94(%rbx)
movl (%rbx), %eax
movl 0x98(%rbx), %ecx
movl %eax, %edx
subl %ecx, %edx
notl %eax
addl %ecx, %eax
imull %ecx, %ecx
imull %edx, %eax
addl %ecx, %eax
addl %eax, %ebp
jmp 0xb6a61
movl $0x0, 0x60(%rbx)
movl %ebp, 0x9c(%rbx)
movslq %r15d, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x8460
movq %rax, 0xc0(%rbx)
testq %rax, %rax
je 0xb6c26
movq %r12, %rdi
callq 0x8460
movq %rax, 0xb8(%rbx)
testq %rax, %rax
je 0xb6c6a
testl %r15d, %r15d
jle 0xb6add
movslq %ebp, %r12
movl %r15d, %r15d
xorl %ebp, %ebp
movl $0x4, %esi
movq %r12, %rdi
callq 0x8250
movq 0xb8(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0xb8(%rbx), %rax
cmpq $0x0, (%rax,%rbp,8)
je 0xb6f89
incq %rbp
cmpq %rbp, %r15
jne 0xb6aab
cmpw $0x1, %r13w
jne 0xb6e72
cmpl $0x1, 0x30(%rbx)
jne 0xb6b0b
movl 0x48(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x64(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x34(%rbx)
jne 0xb6b2e
movl 0x48(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x68(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x38(%rbx)
jne 0xb6b51
movl 0x48(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x6c(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x40(%rbx)
jne 0xb6b74
movl 0x48(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x74(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x44(%rbx)
jne 0xb6b97
movl 0x48(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x78(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x48(%rbx)
jne 0xb6bba
movl 0x48(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x7c(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x4c(%rbx)
jne 0xb6cae
movslq 0x80(%rbx), %rax
movslq 0x80(%rbx), %rcx
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
movslq %esi, %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0xb6cae
movl 0x54(%r14), %ecx
movq 0xb8(%rbx), %rdx
movslq 0x848(%r14), %rsi
movq (%rdx,%rsi,8), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
jmp 0xb6bcb
shll $0x3, %r15d
leaq 0x3a3d3(%rip), %rsi     # 0xf1004
leaq 0x6dd9c(%rip), %rdx     # 0x1249d4
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0x3a3de(%rip), %rsi     # 0xf1034
leaq 0x6dd2a(%rip), %rdx     # 0x124987
movq %rbx, %rdi
movl $0x23c, %ecx            # imm = 0x23C
jmp 0xb6fc6
shll $0x3, %r15d
leaq 0x3a38f(%rip), %rsi     # 0xf1004
leaq 0x6dd63(%rip), %rdx     # 0x1249df
movq %rsp, %r14
movq %r14, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0x3a39a(%rip), %rsi     # 0xf1034
leaq 0x6dce6(%rip), %rdx     # 0x124987
movq %rbx, %rdi
movl $0x23d, %ecx            # imm = 0x23D
jmp 0xb6fc6
cmpl $0x1, 0x50(%rbx)
jne 0xb6cff
cmpl $0x0, 0x98(%rbx)
jle 0xb6cff
movslq 0x84(%rbx), %rax
movq 0xb8(%rbx), %rcx
movl 0x48(%r14), %edx
movl 0x54(%r14), %esi
cmpl %esi, %edx
cmovll %edx, %esi
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rdx
movl %esi, (%rdx,%rax,4)
incq %rax
movslq 0x84(%rbx), %rdx
movslq 0x98(%rbx), %rsi
addq %rdx, %rsi
cmpq %rsi, %rax
jl 0xb6ccb
cmpl $0x1, 0x54(%rbx)
jne 0xb6d50
cmpl $0x0, 0x98(%rbx)
jle 0xb6d50
movslq 0x88(%rbx), %rax
movq 0xb8(%rbx), %rcx
movl 0x48(%r14), %edx
movl 0x54(%r14), %esi
cmpl %esi, %edx
cmovll %edx, %esi
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rdx
movl %esi, (%rdx,%rax,4)
incq %rax
movslq 0x88(%rbx), %rdx
movslq 0x98(%rbx), %rsi
addq %rdx, %rsi
cmpq %rsi, %rax
jl 0xb6d1c
cmpl $0x1, 0x58(%rbx)
jne 0xb6db4
movslq 0x8c(%rbx), %rax
movslq 0x8c(%rbx), %rcx
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
movslq %esi, %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0xb6db4
movl 0x54(%r14), %ecx
movq 0xb8(%rbx), %rdx
movslq 0x848(%r14), %rsi
movq (%rdx,%rsi,8), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
jmp 0xb6d5d
cmpl $0x1, 0x5c(%rbx)
jne 0xb6e05
cmpl $0x0, 0x98(%rbx)
jle 0xb6e05
movslq 0x90(%rbx), %rax
movq 0xb8(%rbx), %rcx
movl 0x48(%r14), %edx
movl 0x54(%r14), %esi
cmpl %esi, %edx
cmovll %edx, %esi
movslq 0x848(%r14), %rdx
movq (%rcx,%rdx,8), %rdx
movl %esi, (%rdx,%rax,4)
incq %rax
movslq 0x90(%rbx), %rdx
movslq 0x98(%rbx), %rsi
addq %rdx, %rsi
cmpq %rsi, %rax
jl 0xb6dd1
cmpl $0x1, 0x60(%rbx)
jne 0xb6e72
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 0xb6e72
movq 0xb8(%rbx), %rcx
movl 0x54(%r14), %edx
movslq 0x848(%r14), %rsi
movq (%rcx,%rsi,8), %rsi
movl %edx, (%rsi,%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 0xb6e37
cmpw $0x1, 0x12(%r14)
jne 0xb6f0a
cmpl $0x1, 0x30(%rbx)
jne 0xb6ea1
movl 0x50(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x84c(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x64(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x34(%rbx)
jne 0xb6ec4
movl 0x50(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x84c(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x68(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x38(%rbx)
jne 0xb6ee7
movl 0x50(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x84c(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x6c(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $0x1, 0x3c(%rbx)
jne 0xb6f0a
movl 0x50(%r14), %eax
movq 0xb8(%rbx), %rcx
movslq 0x84c(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x70(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
movl $0x0, 0xc8(%rbx)
cmpl $0x0, 0x10(%rbx)
jle 0xb6f85
movq 0xc0(%rbx), %rcx
xorl %edx, %edx
movl $0x0, (%rcx,%rdx,4)
cmpl $0x0, 0x9c(%rbx)
jle 0xb6f61
movq 0xb8(%rbx), %rax
movq (%rax,%rdx,8), %rax
xorl %esi, %esi
movl (%rcx,%rdx,4), %edi
movl (%rax,%rsi,4), %r8d
cmpl %r8d, %edi
cmovgl %edi, %r8d
movl %r8d, (%rcx,%rdx,4)
incq %rsi
movslq 0x9c(%rbx), %rdi
cmpq %rdi, %rsi
jl 0xb6f40
movl 0xc8(%rbx), %eax
movl (%rcx,%rdx,4), %esi
cmpl %esi, %eax
cmovgl %eax, %esi
movl %esi, 0xc8(%rbx)
incq %rdx
movslq 0x10(%rbx), %rsi
xorl %eax, %eax
cmpq %rsi, %rdx
jl 0xb6f23
jmp 0xb6fd5
xorl %eax, %eax
jmp 0xb6fd5
leaq 0x3a074(%rip), %rsi     # 0xf1004
leaq 0x6da56(%rip), %rdx     # 0x1249ed
movq %rsp, %r14
movq %r14, %rdi
movl $0x4, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0x3a07d(%rip), %rsi     # 0xf1034
leaq 0x6d9c9(%rip), %rdx     # 0x124987
movq %rbx, %rdi
movl $0x23f, %ecx            # imm = 0x23F
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq