// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../source/output.c
// Function: output_pk
int output_pk(
              struct background * pba,
              struct perturbations * ppt,
              struct fourier * pfo,
              struct output * pop,
              enum pk_outputs pk_output
              ) {

  /** Summary: */

  /** - define local variables */

  FILE ** out_pk_ic = NULL;  /* out_pk_ic[index_ic1_ic2] is a pointer to a file with P(k) for each pair of ic */
  FILE * out_pk;             /* out_pk[index_pk] is a pointer to a file with total P(k) summed over ic */

  double * ln_pk_ic = NULL;  /* array ln_pk_ic[index_k * pfo->ic_ic_size + index_ic1_ic2] */
  double * ln_pk;            /* array ln_pk[index_k] */

  int index_ic1,index_ic2;
  int index_ic1_ic2=0;
  int index_k;
  int index_z;
  int index_pk;

  FileName file_name;

  char redshift_suffix[7]; // 7 is enough to write "z%d_" as long as there are at most 10'000 bins
  char type_suffix[9];     // 6 is enough to write "pk_cb_nl" plus closing character \0
  char first_line[_LINE_LENGTH_MAX_];
  short do_ic = _FALSE_;

  /** - preliminary: check whether we need to output the decomposition into contributions from each initial condition */

  if ((pk_output == pk_linear) && (pfo->ic_size > 1))
    do_ic = _TRUE_;

  /** - allocate arrays to store the P(k) */

  class_alloc(ln_pk,
              pfo->k_size*sizeof(double),
              pop->error_message);

  if (do_ic == _TRUE_) {

    class_alloc(ln_pk_ic,
                pfo->k_size*pfo->ic_ic_size*sizeof(double),
                pop->error_message);

    /** - allocate pointer to output files */

    class_alloc(out_pk_ic,
                pfo->ic_ic_size*sizeof(FILE *),
                pop->error_message);
  }

  /** - deal with linear or nonlinear power spectrum (nowiggle spectrum done separately) */

  if ((pk_output == pk_linear) || (pk_output == pk_nonlinear)) {

    /** - loop over pk type (_cb, _m) */

    for (index_pk=0; index_pk<pfo->pk_size; index_pk++) {

      if ((pfo->has_pk_m == _TRUE_) && (index_pk == pfo->index_pk_m)) {
        if (pk_output == pk_linear)
          class_sprintf(type_suffix,"pk");
        else
          class_sprintf(type_suffix,"pk_nl");
      }
      if ((pfo->has_pk_cb == _TRUE_) && (index_pk == pfo->index_pk_cb)) {
        if (pk_output == pk_linear)
          class_sprintf(type_suffix,"pk_cb");
        else
          class_sprintf(type_suffix,"pk_cb_nl");
      }

      /** - loop over z */

      for (index_z = 0; index_z < pop->z_pk_num; index_z++) {

        /** - first, check that requested redshift z_pk is consistent */

        class_test((pop->z_pk[index_z] > ppt->z_max_pk),
                   pop->error_message,
                   "P(k,z) computed up to z=%f but requested at z=%f. Must increase z_max_pk in precision file.",ppt->z_max_pk,pop->z_pk[index_z]);

        if (pop->z_pk_num == 1)
          redshift_suffix[0]='\0';
        else
          class_sprintf(redshift_suffix,"z%d_",index_z+1);

        /** - second, open only the relevant files and write a header in each of them */

        class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,".dat");

        class_call(output_open_pk_file(pba,
                                       pfo,
                                       pop,
                                       &out_pk,
                                       file_name,
                                       "",
                                       pop->z_pk[index_z]
                                       ),
                   pop->error_message,
                   pop->error_message);

        if (do_ic == _TRUE_) {

          for (index_ic1 = 0; index_ic1 < pfo->ic_size; index_ic1++) {

            for (index_ic2 = index_ic1; index_ic2 < pfo->ic_size; index_ic2++) {

              if ((ppt->has_ad == _TRUE_) && (index_ic1 == ppt->index_ic_ad) && (index_ic2 == ppt->index_ic_ad)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_ad.dat");
                strcpy(first_line,"for adiabatic (AD) mode ");
              }

              if ((ppt->has_bi == _TRUE_) && (index_ic1 == ppt->index_ic_bi) && (index_ic2 == ppt->index_ic_bi)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_bi.dat");
                strcpy(first_line,"for baryon isocurvature (BI) mode ");
              }

              if ((ppt->has_cdi == _TRUE_) && (index_ic1 == ppt->index_ic_cdi) && (index_ic2 == ppt->index_ic_cdi)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_cdi.dat");
                strcpy(first_line,"for CDM isocurvature (CDI) mode ");
              }

              if ((ppt->has_nid == _TRUE_) && (index_ic1 == ppt->index_ic_nid) && (index_ic2 == ppt->index_ic_nid)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_nid.dat");
                strcpy(first_line,"for neutrino density isocurvature (NID) mode ");
              }

              if ((ppt->has_niv == _TRUE_) && (index_ic1 == ppt->index_ic_niv) && (index_ic2 == ppt->index_ic_niv)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_niv.dat");
                strcpy(first_line,"for neutrino velocity isocurvature (NIV) mode ");
              }

              if ((ppt->has_ad == _TRUE_) && (ppt->has_bi == _TRUE_) && (index_ic1 == ppt->index_ic_ad) && (index_ic2 == ppt->index_ic_bi)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_ad_bi.dat");
                strcpy(first_line,"for cross ADxBI mode ");
              }

              if ((ppt->has_ad == _TRUE_) && (ppt->has_cdi == _TRUE_) && (index_ic1 == ppt->index_ic_ad) && (index_ic2 == ppt->index_ic_cdi)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_ad_cdi.dat");
                strcpy(first_line,"for cross ADxCDI mode ");
              }

              if ((ppt->has_ad == _TRUE_) && (ppt->has_nid == _TRUE_) && (index_ic1 == ppt->index_ic_ad) && (index_ic2 == ppt->index_ic_nid)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_ad_nid.dat");
                strcpy(first_line,"for scalar cross ADxNID mode ");
              }

              if ((ppt->has_ad == _TRUE_) && (ppt->has_niv == _TRUE_) && (index_ic1 == ppt->index_ic_ad) && (index_ic2 == ppt->index_ic_niv)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_ad_niv.dat");
                strcpy(first_line,"for cross ADxNIV mode ");
              }

              if ((ppt->has_bi == _TRUE_) && (ppt->has_cdi == _TRUE_) && (index_ic1 == ppt->index_ic_bi) && (index_ic2 == ppt->index_ic_cdi)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_bi_cdi.dat");
                strcpy(first_line,"for cross BIxCDI mode ");
              }

              if ((ppt->has_bi == _TRUE_) && (ppt->has_nid == _TRUE_) && (index_ic1 == ppt->index_ic_bi) && (index_ic2 == ppt->index_ic_nid)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_bi_nid.dat");
                strcpy(first_line,"for cross BIxNID mode ");
              }

              if ((ppt->has_bi == _TRUE_) && (ppt->has_niv == _TRUE_) && (index_ic1 == ppt->index_ic_bi) && (index_ic2 == ppt->index_ic_niv)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_bi_niv.dat");
                strcpy(first_line,"for cross BIxNIV mode ");
              }

              if ((ppt->has_cdi == _TRUE_) && (ppt->has_nid == _TRUE_) && (index_ic1 == ppt->index_ic_cdi) && (index_ic2 == ppt->index_ic_nid)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_cdi_nid.dat");
                strcpy(first_line,"for cross CDIxNID mode ");
              }

              if ((ppt->has_cdi == _TRUE_) && (ppt->has_niv == _TRUE_) && (index_ic1 == ppt->index_ic_cdi) && (index_ic2 == ppt->index_ic_niv)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_cdi_niv.dat");
                strcpy(first_line,"for cross CDIxNIV mode ");
              }

              if ((ppt->has_nid == _TRUE_) && (ppt->has_niv == _TRUE_) && (index_ic1 == ppt->index_ic_nid) && (index_ic2 == ppt->index_ic_niv)) {
                class_sprintf(file_name,"%s%s%s%s",pop->root,redshift_suffix,type_suffix,"_nid_niv.dat");
                strcpy(first_line,"for cross NIDxNIV mode ");
              }

              index_ic1_ic2 = index_symmetric_matrix(index_ic1,index_ic2,pfo->ic_size);

              if (pfo->is_non_zero[index_ic1_ic2] == _TRUE_) {

                class_call(output_open_pk_file(pba,
                                               pfo,
                                               pop,
                                               &(out_pk_ic[index_ic1_ic2]),
                                               file_name,
                                               first_line,
                                               pop->z_pk[index_z]
                                               ),
                           pop->error_message,
                           pop->error_message);
              }
            }
          }
        }

        /** - third, compute P(k) for each k */

        class_call(fourier_pk_at_z(pba,
                                   pfo,
                                   logarithmic,
                                   pk_output,
                                   pop->z_pk[index_z],
                                   index_pk,
                                   ln_pk,
                                   ln_pk_ic
                                   ),
                   pfo->error_message,
                   pop->error_message);

        /** - fourth, write in files */

        for (index_k=0; index_k<pfo->k_size; index_k++) {

          class_call(output_one_line_of_pk(out_pk,
                                           exp(pfo->ln_k[index_k])/pba->h,
                                           exp(ln_pk[index_k])*pow(pba->h,3)
                                           ),
                     pop->error_message,
                     pop->error_message);

          if (do_ic == _TRUE_) {

            for (index_ic1_ic2 = 0; index_ic1_ic2 < pfo->ic_ic_size; index_ic1_ic2++) {

              if (pfo->is_non_zero[index_ic1_ic2] == _TRUE_) {

                class_call(output_one_line_of_pk(out_pk_ic[index_ic1_ic2],
                                                 exp(pfo->ln_k[index_k])/pba->h,
                                                 exp(ln_pk_ic[index_k * pfo->ic_ic_size + index_ic1_ic2])*pow(pba->h,3)),
                           pop->error_message,
                           pop->error_message);
              }
            }
          }
        } /* end loop over k */

        /** - fifth, close files */

        fclose(out_pk);

        if (do_ic == _TRUE_) {
          for (index_ic1_ic2 = 0; index_ic1_ic2 < pfo->ic_ic_size; index_ic1_ic2++) {
            if (pfo->is_non_zero[index_ic1_ic2] == _TRUE_) {
              fclose(out_pk_ic[index_ic1_ic2]);
            }
          }
        }

      } /* end loop over index_z */

    } /* end loop over index_pk */

  } /* end cases pk_linear or pk_nonlinear */

  else if (pk_output == pk_numerical_nowiggle) {

    /** - loop over z */

    for (index_z = 0; index_z < pop->z_pk_num; index_z++) {

      /** - first, check that requested redshift z_pk is consistent */

      class_test((pop->z_pk[index_z] > ppt->z_max_pk),
                 pop->error_message,
                 "P(k,z) computed up to z=%f but requested at z=%f. Must increase z_max_pk in precision file.",ppt->z_max_pk,pop->z_pk[index_z]);

      if (pop->z_pk_num == 1)
        redshift_suffix[0]='\0';
      else
        class_sprintf(redshift_suffix,"z%d_",index_z+1);

      /** - second, open only the relevant files and write a header in each of them */

      class_sprintf(file_name,"%s%spk_nw.dat",pop->root,redshift_suffix);

      class_call(output_open_pk_file(pba,
                                     pfo,
                                     pop,
                                     &out_pk,
                                     file_name,
                                     "",
                                     pop->z_pk[index_z]
                                     ),
                 pop->error_message,
                 pop->error_message);

      /** - third, compute P(k) for each k */

      class_call(fourier_pk_at_z(pba,
                                 pfo,
                                 logarithmic,
                                 pk_output,
                                 pop->z_pk[index_z],
                                 0, // index_pk irrelevant for the nowiggle spectrum
                                 ln_pk,
                                 NULL
                                 ),
                 pfo->error_message,
                 pop->error_message);

      /** - fourth, write in files */

      for (index_k=0; index_k<pfo->k_size; index_k++) {

        class_call(output_one_line_of_pk(out_pk,
                                         exp(pfo->ln_k[index_k])/pba->h,
                                         exp(ln_pk[index_k])*pow(pba->h,3)
                                         ),
                   pop->error_message,
                   pop->error_message);

      } /* end loop over k */

        /** - fifth, close files */

      fclose(out_pk);

    } /* end loop over index_z */

  } /* end cases pk_numerical_nowiggle */

  /** - deal with analytic nowiggle power spectrum at z=0 */

  else if (pk_output == pk_analytic_nowiggle) {

    class_sprintf(file_name,"%spk_analytic_nowiggle.dat",pop->root);

    class_call(output_open_pk_file(pba,
                                   pfo,
                                   pop,
                                   &out_pk,
                                   file_name,
                                   "",
                                   0.
                                   ),
               pop->error_message,
               pop->error_message);

    for (index_k=0; index_k<pfo->k_size; index_k++) {

      class_call(output_one_line_of_pk(out_pk,
                                       pfo->k[index_k]/pba->h,
                                       exp(pfo->ln_pk_l_an_extra[index_k])*pow(pba->h,3)
                                       ),
                 pop->error_message,
                 pop->error_message);
    }

    fclose(out_pk);
  }

  else {
    class_stop(pop->error_message,"pk_output = %d not recognized",pk_output);
  }

  /* free arrays and pointers */
  free(ln_pk);
  if (do_ic == _TRUE_) {
    free(ln_pk_ic);
    free(out_pk_ic);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1598, %rsp           # imm = 0x1598
movq %rdx, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, %rbx
movl %r8d, 0x5c(%rsp)
movq %rcx, %r15
testl %r8d, %r8d
je 0xebc0c
movl $0x0, 0x38(%rsp)
jmp 0xebc19
cmpl $0x2, 0x40(%r12)
setge %al
movl %eax, 0x38(%rsp)
movslq 0x6c(%r12), %r13
leaq (,%r13,8), %rdi
callq 0x8460
testq %rax, %rax
je 0xebccd
movq %rax, 0x68(%rsp)
cmpb $0x0, 0x38(%rsp)
je 0xebd16
movslq 0x44(%r12), %rbp
imulq %rbp, %r13
leaq (,%r13,8), %rdi
callq 0x8460
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0xecea0
leaq (,%rbp,8), %rdi
callq 0x8460
movq %rax, 0x70(%rsp)
testq %rax, %rax
jne 0xebd2b
shll $0x3, %ebp
leaq 0x5374(%rip), %rsi      # 0xf1004
leaq 0x463e9(%rip), %rdx     # 0x132080
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x420, %r15            # imm = 0x420
leaq 0x537b(%rip), %rsi      # 0xf1034
leaq 0x463ad(%rip), %rdx     # 0x13206d
movq %r15, %rdi
movl $0x2b4, %ecx            # imm = 0x2B4
jmp 0xed232
shll $0x3, %r13d
leaq 0x532c(%rip), %rsi      # 0xf1004
leaq 0x46388(%rip), %rdx     # 0x132067
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x420, %r15            # imm = 0x420
leaq 0x5332(%rip), %rsi      # 0xf1034
leaq 0x46364(%rip), %rdx     # 0x13206d
movq %r15, %rdi
movl $0x2a8, %ecx            # imm = 0x2A8
jmp 0xed232
movq $0x0, 0x80(%rsp)
movq $0x0, 0x70(%rsp)
movl 0x5c(%rsp), %edx
cmpl $0x1, %edx
movq 0x30(%rsp), %rcx
ja 0xeccbb
movq %rbx, 0x48(%rsp)
cmpl $0x0, 0x64(%r12)
jle 0xed0b8
leaq 0x9(%rsp), %rbp
movl $0x0, 0x3c(%rsp)
movq %r15, 0x18(%rsp)
cmpw $0x1, 0x50(%r12)
jne 0xebd95
movl 0x3c(%rsp), %eax
cmpl 0x54(%r12), %eax
jne 0xebd95
testl %edx, %edx
je 0xebd89
movw $0x6c, 0x24(%rsp)
movl $0x6e5f6b70, 0x20(%rsp) # imm = 0x6E5F6B70
jmp 0xebd95
movb $0x0, 0x22(%rsp)
movw $0x6b70, 0x20(%rsp)     # imm = 0x6B70
cmpw $0x1, 0x52(%r12)
jne 0xebdd2
movl 0x3c(%rsp), %eax
cmpl 0x58(%r12), %eax
jne 0xebdd2
testl %edx, %edx
je 0xebdc3
movabsq $0x6c6e5f62635f6b70, %rax # imm = 0x6C6E5F62635F6B70
movq %rax, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
jmp 0xebdd2
movw $0x62, 0x24(%rsp)
movl $0x635f6b70, 0x20(%rsp) # imm = 0x635F6B70
movl 0xe0(%r15), %eax
testl %eax, %eax
jle 0xecc9d
xorl %edx, %edx
movsd 0xe8(%r15,%rdx,8), %xmm1
movsd 0x818(%rcx), %xmm0
ucomisd %xmm0, %xmm1
ja 0xed0eb
cmpl $0x1, %eax
movq %rdx, 0x60(%rsp)
jne 0xebe10
movb $0x0, 0x9(%rsp)
jmp 0xebe45
leal 0x1(%rdx), %ebp
xorl %edi, %edi
xorl %esi, %esi
leaq 0x462fc(%rip), %rbx     # 0x13211a
movq %rbx, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x9(%rsp), %rdi
movq %rbx, %rdx
movl %ebp, %ecx
leaq 0x9(%rsp), %rbp
xorl %eax, %eax
callq 0x8550
leaq 0xa26f(%rip), %r14      # 0xf60bb
movq %r14, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46a01(%rip), %r13     # 0x13285c
movq %r13, %rdx
movq 0x18(%rsp), %r15
movq %r15, %rcx
movq %rbp, %r8
leaq 0x20(%rsp), %rbx
movq %rbx, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
movq %r14, (%rsp)
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %rbp, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x8550
movq 0x60(%rsp), %rax
movsd 0xe8(%r15,%rax,8), %xmm0
movq 0x48(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x50(%rsp), %rcx
movq %r14, %r8
leaq 0x479f4(%rip), %r9      # 0x1338bc
callq 0xf0338
testl %eax, %eax
jne 0xed14c
cmpb $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rdx
je 0xeca8d
cmpl $0x0, 0x40(%r12)
jle 0xeca8d
movl $0x2, %eax
movl $0x0, 0x7c(%rsp)
xorl %ebx, %ebx
movl %eax, 0x88(%rsp)
cmpl 0x40(%r12), %ebx
jge 0xeca72
movl 0x7c(%rsp), %eax
shrl %eax
negl %eax
movq %rax, 0x40(%rsp)
movl %ebx, %ebp
movl %ebx, 0x10(%rsp)
cmpw $0x1, 0x14(%rdx)
jne 0xebfce
movl 0x858(%rdx), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xebfce
leaq 0x45c16(%rip), %rax     # 0x131b61
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46902(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45bd9(%rip), %rax     # 0x131b61
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movups 0x461b8(%rip), %xmm0    # 0x13216f
movaps %xmm0, 0x190(%rsp)
movups 0x461b2(%rip), %xmm0    # 0x132178
movups %xmm0, 0x199(%rsp)
cmpw $0x1, 0x16(%rdx)
jne 0xec082
movl 0x860(%rdx), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xec082
leaq 0x45ce1(%rip), %rax     # 0x131cd5
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46859(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45ca4(%rip), %rax     # 0x131cd5
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movups 0x46128(%rip), %xmm0    # 0x132188
movaps %xmm0, 0x190(%rsp)
movups 0x46129(%rip), %xmm0    # 0x132198
movaps %xmm0, 0x1a0(%rsp)
movl $0x206564, 0x1af(%rsp) # imm = 0x206564
cmpw $0x1, 0x18(%rdx)
jne 0xec133
movl 0x85c(%rdx), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xec133
leaq 0x45c6a(%rip), %rax     # 0x131d12
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x467a5(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45c2d(%rip), %rax     # 0x131d12
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movups 0x46097(%rip), %xmm0    # 0x1321ab
movaps %xmm0, 0x190(%rsp)
movups 0x46098(%rip), %xmm0    # 0x1321bb
movaps %xmm0, 0x1a0(%rsp)
movb $0x0, 0x1b0(%rsp)
cmpw $0x1, 0x1a(%rdx)
jne 0xec1eb
movl 0x864(%rdx), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xec1eb
leaq 0x45bf8(%rip), %rax     # 0x131d51
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x466f4(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45bbb(%rip), %rax     # 0x131d51
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movups 0x46007(%rip), %xmm0    # 0x1321cc
movaps %xmm0, 0x190(%rsp)
movups 0x46008(%rip), %xmm0    # 0x1321dc
movaps %xmm0, 0x1a0(%rsp)
movups 0x46007(%rip), %xmm0    # 0x1321ea
movups %xmm0, 0x1ae(%rsp)
cmpw $0x1, 0x1c(%rdx)
jne 0xec2a3
movl 0x868(%rdx), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xec2a3
leaq 0x45b7f(%rip), %rax     # 0x131d90
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4663c(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45b42(%rip), %rax     # 0x131d90
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movups 0x45f7d(%rip), %xmm0    # 0x1321fa
movaps %xmm0, 0x190(%rsp)
movups 0x45f7e(%rip), %xmm0    # 0x13220a
movaps %xmm0, 0x1a0(%rsp)
movups 0x45f7e(%rip), %xmm0    # 0x132219
movups %xmm0, 0x1af(%rsp)
cmpw $0x1, 0x14(%rdx)
jne 0xec35e
cmpw $0x1, 0x16(%rdx)
jne 0xec35e
cmpl 0x858(%rdx), %ebx
jne 0xec35e
cmpl 0x860(%rdx), %ebp
jne 0xec35e
leaq 0x459fa(%rip), %rax     # 0x131cd2
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46575(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x459bd(%rip), %rax     # 0x131cd2
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19e(%rsp)
movups 0x45ed3(%rip), %xmm0    # 0x132229
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdx)
jne 0xec419
cmpw $0x1, 0x18(%rdx)
jne 0xec419
cmpl 0x858(%rdx), %ebx
jne 0xec419
cmpl 0x85c(%rdx), %ebp
jne 0xec419
leaq 0x4597c(%rip), %rax     # 0x131d0f
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x464ba(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x4593f(%rip), %rax     # 0x131d0f
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19f(%rsp)
movups 0x45e2e(%rip), %xmm0    # 0x13223f
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdx)
jne 0xec4d1
cmpw $0x1, 0x1a(%rdx)
jne 0xec4d1
cmpl 0x858(%rdx), %ebx
jne 0xec4d1
cmpl 0x864(%rdx), %ebp
jne 0xec4d1
leaq 0x45900(%rip), %rax     # 0x131d4e
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x463ff(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x458c3(%rip), %rax     # 0x131d4e
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movups 0x45d9c(%rip), %xmm0    # 0x132256
movaps %xmm0, 0x190(%rsp)
movups 0x45d9b(%rip), %xmm0    # 0x132264
movups %xmm0, 0x19e(%rsp)
cmpw $0x1, 0x14(%rdx)
jne 0xec58c
cmpw $0x1, 0x1c(%rdx)
jne 0xec58c
cmpl 0x858(%rdx), %ebx
jne 0xec58c
cmpl 0x868(%rdx), %ebp
jne 0xec58c
leaq 0x45887(%rip), %rax     # 0x131d8d
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46347(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x4584a(%rip), %rax     # 0x131d8d
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x19f(%rsp)
movups 0x45cf0(%rip), %xmm0    # 0x132274
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdx)
jne 0xec647
cmpw $0x1, 0x18(%rdx)
jne 0xec647
cmpl 0x860(%rdx), %ebx
jne 0xec647
cmpl 0x85c(%rdx), %ebp
jne 0xec647
leaq 0x4580b(%rip), %rax     # 0x131dcc
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4628c(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x457ce(%rip), %rax     # 0x131dcc
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19f(%rsp)
movups 0x45c4c(%rip), %xmm0    # 0x13228b
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdx)
jne 0xec702
cmpw $0x1, 0x1a(%rdx)
jne 0xec702
cmpl 0x860(%rdx), %ebx
jne 0xec702
cmpl 0x864(%rdx), %ebp
jne 0xec702
leaq 0x4578f(%rip), %rax     # 0x131e0b
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x461d1(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45752(%rip), %rax     # 0x131e0b
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2044, %rax # imm = 0x2065646F6D2044
movq %rax, 0x19f(%rsp)
movups 0x45ba8(%rip), %xmm0    # 0x1322a2
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdx)
jne 0xec7bd
cmpw $0x1, 0x1c(%rdx)
jne 0xec7bd
cmpl 0x860(%rdx), %ebx
jne 0xec7bd
cmpl 0x868(%rdx), %ebp
jne 0xec7bd
leaq 0x45713(%rip), %rax     # 0x131e4a
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46116(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x456d6(%rip), %rax     # 0x131e4a
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x19f(%rsp)
movups 0x45b04(%rip), %xmm0    # 0x1322b9
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x18(%rdx)
jne 0xec878
cmpw $0x1, 0x1a(%rdx)
jne 0xec878
cmpl 0x85c(%rdx), %ebx
jne 0xec878
cmpl 0x864(%rdx), %ebp
jne 0xec878
leaq 0x45697(%rip), %rax     # 0x131e89
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4605b(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x4565a(%rip), %rax     # 0x131e89
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2044, %rax # imm = 0x2065646F6D2044
movq %rax, 0x1a0(%rsp)
movups 0x45a60(%rip), %xmm0    # 0x1322d0
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x18(%rdx)
jne 0xec933
cmpw $0x1, 0x1c(%rdx)
jne 0xec933
cmpl 0x85c(%rdx), %ebx
jne 0xec933
cmpl 0x868(%rdx), %ebp
jne 0xec933
leaq 0x4561d(%rip), %rax     # 0x131eca
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45fa0(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x455e0(%rip), %rax     # 0x131eca
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movq 0x30(%rsp), %rdx
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x1a0(%rsp)
movups 0x459bd(%rip), %xmm0    # 0x1322e8
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x1a(%rdx)
jne 0xec9e9
cmpw $0x1, 0x1c(%rdx)
jne 0xec9e9
cmpl 0x864(%rdx), %ebx
jne 0xec9e9
cmpl 0x868(%rdx), %ebp
jne 0xec9e9
leaq 0x455a3(%rip), %rax     # 0x131f0b
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45ee5(%rip), %r14     # 0x13285c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x20(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45566(%rip), %rax     # 0x131f0b
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
movl 0x10(%rsp), %ebx
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x1a0(%rsp)
movups 0x4591f(%rip), %xmm0    # 0x132300
movaps %xmm0, 0x190(%rsp)
movl 0x40(%r12), %eax
cmpl %ebp, %ebx
jbe 0xeca05
imull %ebp, %eax
leal 0x1(%rbp), %ecx
imull %ebp, %ecx
shrl %ecx
movl %ebx, %edx
subl %ecx, %edx
addl %edx, %eax
jmp 0xeca11
imull %ebx, %eax
movq 0x40(%rsp), %rcx
addl %ebp, %ecx
addl %ecx, %eax
movq 0x48(%r12), %rcx
cltq
cmpw $0x1, (%rcx,%rax,2)
jne 0xeca60
movq 0x70(%rsp), %rcx
leaq (%rcx,%rax,8), %rcx
movq 0x18(%rsp), %rdx
movq 0x60(%rsp), %rax
movsd 0xe8(%rdx,%rax,8), %xmm0
movq 0x48(%rsp), %rdi
movq %r12, %rsi
leaq 0x90(%rsp), %r8
leaq 0x190(%rsp), %r9
callq 0xf0338
testl %eax, %eax
jne 0xecee9
incl %ebp
cmpl 0x40(%r12), %ebp
movq 0x30(%rsp), %rdx
jl 0xebf25
incl %ebx
movl 0x88(%rsp), %eax
addl %eax, 0x7c(%rsp)
addl $0x2, %eax
cmpl 0x40(%r12), %ebx
jl 0xebf00
movq 0x18(%rsp), %rax
movq 0x60(%rsp), %rcx
movsd 0xe8(%rax,%rcx,8), %xmm0
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movq %r12, %rsi
movl $0x1, %edx
movl 0x5c(%rsp), %ecx
movl 0x3c(%rsp), %r8d
movq 0x68(%rsp), %r9
callq 0x9ff68
cmpl $0x1, %eax
je 0xed2a4
cmpl $0x0, 0x6c(%r12)
jle 0xecc2a
movq 0x50(%rsp), %rax
movq %rax, 0x88(%rsp)
xorl %ebx, %ebx
movq 0x80(%r12), %rax
movsd (%rax,%rbx,8), %xmm0
callq 0x8670
movq 0x48(%rsp), %r15
divsd 0x8(%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x68(%rsp), %rax
movsd (%rax,%rbx,8), %xmm0
callq 0x8670
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r15), %xmm0
movsd 0x5b4a(%rip), %xmm1     # 0xf2680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq 0x88(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0xf04fe
cmpb $0x0, 0x38(%rsp)
je 0xecc19
cmpl $0x0, 0x44(%r12)
jle 0xecc19
movslq %ebx, %r13
xorl %r15d, %r15d
movq 0x48(%r12), %rax
cmpw $0x1, (%rax,%r15,2)
jne 0xecc08
movq 0x70(%rsp), %rax
movq (%rax,%r15,8), %rbp
movq 0x80(%r12), %rax
movsd (%rax,%rbx,8), %xmm0
callq 0x8670
movq %r12, %r14
movq 0x48(%rsp), %r12
divsd 0x8(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0x44(%r14), %rax
imulq %r13, %rax
addq %r15, %rax
movq 0x80(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm0
callq 0x8670
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r12), %xmm0
movq %r14, %r12
movsd 0x5a95(%rip), %xmm1     # 0xf2680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %rbp, %rdi
movsd 0x10(%rsp), %xmm0
callq 0xf04fe
incq %r15
movslq 0x44(%r12), %rax
cmpq %rax, %r15
jl 0xecb75
incq %rbx
movslq 0x6c(%r12), %rax
cmpq %rax, %rbx
jl 0xecaf0
movq 0x50(%rsp), %rdi
callq 0x83a0
cmpb $0x0, 0x38(%rsp)
movq 0x18(%rsp), %r15
movq 0x30(%rsp), %rcx
leaq 0x9(%rsp), %rbp
movq 0x60(%rsp), %rdx
je 0xecc8a
cmpl $0x0, 0x44(%r12)
jle 0xecc8a
xorl %ebx, %ebx
movq 0x48(%r12), %rax
cmpw $0x1, (%rax,%rbx,2)
jne 0xecc7d
movq 0x70(%rsp), %rax
movq (%rax,%rbx,8), %rdi
callq 0x83a0
movq 0x60(%rsp), %rdx
movq 0x30(%rsp), %rcx
incq %rbx
movslq 0x44(%r12), %rax
cmpq %rax, %rbx
jl 0xecc59
incq %rdx
movslq 0xe0(%r15), %rax
cmpq %rax, %rdx
jl 0xebde3
movl 0x3c(%rsp), %eax
incl %eax
movl %eax, 0x3c(%rsp)
cmpl 0x64(%r12), %eax
movl 0x5c(%rsp), %edx
jl 0xebd60
jmp 0xed0b8
cmpl $0x3, %edx
je 0xecf33
cmpl $0x2, %edx
jne 0xecfd8
movl 0xe0(%r15), %eax
testl %eax, %eax
jle 0xed0b8
leaq 0x9(%rsp), %rbp
xorl %edx, %edx
movsd 0xe8(%r15,%rdx,8), %xmm1
movsd 0x818(%rcx), %xmm0
ucomisd %xmm0, %xmm1
ja 0xed191
cmpl $0x1, %eax
movq %rdx, 0x48(%rsp)
jne 0xecd10
movb $0x0, 0x9(%rsp)
jmp 0xecd41
leal 0x1(%rdx), %r13d
xorl %edi, %edi
xorl %esi, %esi
leaq 0x453fb(%rip), %r14     # 0x13211a
movq %r14, %rdx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
movq %rbp, %rdi
movq %r14, %rdx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x8550
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4569a(%rip), %r14     # 0x1323e6
movq %r14, %rdx
movq %r15, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x90(%rsp), %r13
movq %r13, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x8550
movq 0x48(%rsp), %r14
movsd 0xe8(%r15,%r14,8), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x50(%rsp), %rcx
movq %r13, %r8
leaq 0x46b19(%rip), %r9      # 0x1338bc
callq 0xf0338
testl %eax, %eax
jne 0xed1f2
movsd 0xe8(%r15,%r14,8), %xmm0
movq $0x0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
movq 0x68(%rsp), %r9
callq 0x9ff68
cmpl $0x1, %eax
je 0xed255
cmpl $0x0, 0x6c(%r12)
movq %r12, %r14
movq %rbx, %r12
movq 0x68(%rsp), %rbp
jle 0xece69
movq 0x50(%rsp), %r13
xorl %ebx, %ebx
movq 0x80(%r14), %rax
movsd (%rax,%rbx,8), %xmm0
callq 0x8670
divsd 0x8(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rbp,%rbx,8), %xmm0
callq 0x8670
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r12), %xmm0
movsd 0x5840(%rip), %xmm1     # 0xf2680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %r13, %rdi
movsd 0x10(%rsp), %xmm0
callq 0xf04fe
incq %rbx
movslq 0x6c(%r14), %rax
cmpq %rax, %rbx
jl 0xece02
movq 0x50(%rsp), %rdi
callq 0x83a0
movq 0x48(%rsp), %rdx
incq %rdx
movslq 0xe0(%r15), %rax
cmpq %rax, %rdx
movq %r12, %rbx
movq %r14, %r12
movq 0x30(%rsp), %rcx
leaq 0x9(%rsp), %rbp
jl 0xecce3
jmp 0xed0b8
shll $0x3, %r13d
leaq 0x4159(%rip), %rsi      # 0xf1004
leaq 0x451c5(%rip), %rdx     # 0x132077
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
addq $0x420, %r15            # imm = 0x420
leaq 0x415f(%rip), %rsi      # 0xf1034
leaq 0x45191(%rip), %rdx     # 0x13206d
movq %r15, %rdi
movl $0x2ae, %ecx            # imm = 0x2AE
jmp 0xed232
movq 0x18(%rsp), %rbx
addq $0x420, %rbx            # imm = 0x420
leaq 0x44f4(%rip), %rsi      # 0xf13f0
leaq 0x45415(%rip), %rdx     # 0x132318
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4115(%rip), %rsi      # 0xf1034
leaq 0x45147(%rip), %rdx     # 0x13206d
movq %rbx, %rdi
movl $0x348, %ecx            # imm = 0x348
jmp 0xed232
movq %r12, %r14
leaq 0x45514(%rip), %r12     # 0x132451
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x90(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x8550
leaq 0x4694a(%rip), %r9      # 0x1338bc
leaq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %r8
callq 0xf0338
testl %eax, %eax
je 0xed035
addq $0x420, %r15            # imm = 0x420
leaq 0x444f(%rip), %rsi      # 0xf13f0
leaq 0x454c4(%rip), %rdx     # 0x13246c
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x4070(%rip), %rsi      # 0xf1034
leaq 0x450a2(%rip), %rdx     # 0x13206d
movq %r15, %rdi
movl $0x3db, %ecx            # imm = 0x3DB
jmp 0xed232
leaq 0x454cd(%rip), %rsi     # 0x1324ac
leaq 0x590(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0x458d(%rip), %rsi      # 0xf1585
movq %r15, %rbx
leaq 0xd90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30c2c
addq $0x420, %rbx            # imm = 0x420
leaq 0x4016(%rip), %rsi      # 0xf1034
leaq 0x45048(%rip), %rdx     # 0x13206d
movq %rbx, %rdi
movl $0x3eb, %ecx            # imm = 0x3EB
movq %r15, %r8
jmp 0xed235
cmpl $0x0, 0x6c(%r14)
jle 0xed0ae
movq %rbx, %r12
movq 0x50(%rsp), %rbx
xorl %r15d, %r15d
movq 0x78(%r14), %rax
movq 0x118(%r14), %rcx
movsd (%rax,%r15,8), %xmm0
divsd 0x8(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rcx,%r15,8), %xmm0
callq 0x8670
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r12), %xmm0
movsd 0x55fb(%rip), %xmm1     # 0xf2680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0xf04fe
incq %r15
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jl 0xed047
movq 0x50(%rsp), %rdi
callq 0x83a0
movq 0x68(%rsp), %rdi
callq 0x8410
xorl %ebx, %ebx
cmpb $0x0, 0x38(%rsp)
je 0xed241
movq 0x80(%rsp), %rdi
callq 0x8410
movq 0x70(%rsp), %rdi
callq 0x8410
jmp 0xed241
leaq 0x44fa7(%rip), %rsi     # 0x132099
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30c2c
leaq 0x3f77(%rip), %rsi      # 0xf1082
leaq 0x44fe3(%rip), %rdx     # 0x1320f5
movq %r15, %rbx
leaq 0xd90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x420, %rbx            # imm = 0x420
leaq 0x3efc(%rip), %rsi      # 0xf1034
leaq 0x44f2e(%rip), %rdx     # 0x13206d
movq %rbx, %rdi
movl $0x2d4, %ecx            # imm = 0x2D4
jmp 0xed02d
addq $0x420, %r15            # imm = 0x420
leaq 0x4296(%rip), %rsi      # 0xf13f0
leaq 0x44fbe(%rip), %rdx     # 0x13211f
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x3eb7(%rip), %rsi      # 0xf1034
leaq 0x44ee9(%rip), %rdx     # 0x13206d
movq %r15, %rdi
movl $0x2e8, %ecx            # imm = 0x2E8
jmp 0xed232
leaq 0x44f01(%rip), %rsi     # 0x132099
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30c2c
leaq 0x3ed1(%rip), %rsi      # 0xf1082
leaq 0x44f3d(%rip), %rdx     # 0x1320f5
movq %r15, %rbx
leaq 0xd90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x420, %rbx            # imm = 0x420
leaq 0x3e56(%rip), %rsi      # 0xf1034
leaq 0x44e88(%rip), %rdx     # 0x13206d
movq %rbx, %rdi
movl $0x393, %ecx            # imm = 0x393
jmp 0xed02d
addq $0x420, %r15            # imm = 0x420
leaq 0x41f0(%rip), %rsi      # 0xf13f0
leaq 0x44f18(%rip), %rdx     # 0x13211f
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0x3e11(%rip), %rsi      # 0xf1034
leaq 0x44e43(%rip), %rdx     # 0x13206d
movq %r15, %rdi
movl $0x3a7, %ecx            # imm = 0x3A7
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %ebx
movl %ebx, %eax
addq $0x1598, %rsp           # imm = 0x1598
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x192, %r12            # imm = 0x192
leaq 0x418d(%rip), %rsi      # 0xf13f0
leaq 0x4518a(%rip), %rdx     # 0x1323f4
movq %r15, %rbx
leaq 0x590(%rsp), %r15
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x420, %rbx            # imm = 0x420
leaq 0x3da4(%rip), %rsi      # 0xf1034
leaq 0x44dd6(%rip), %rdx     # 0x13206d
movq %rbx, %rdi
movl $0x3b5, %ecx            # imm = 0x3B5
jmp 0xed02d
addq $0x192, %r12            # imm = 0x192
leaq 0x413e(%rip), %rsi      # 0xf13f0
leaq 0x450cb(%rip), %rdx     # 0x132384
leaq 0x590(%rsp), %r15
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30c2c
movq 0x18(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
leaq 0x3d53(%rip), %rsi      # 0xf1034
leaq 0x44d85(%rip), %rdx     # 0x13206d
movl $0x35a, %ecx            # imm = 0x35A
jmp 0xed02d