// File: /workspace/github_c_makefile_star2_O2/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 %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, %r15
movl %r8d, 0x5c(%rsp)
testl %r8d, %r8d
je 0xe01a9
movl $0x0, 0x38(%rsp)
jmp 0xe01b5
cmpl $0x2, 0x40(%r14)
setge %al
movl %eax, 0x38(%rsp)
movslq 0x6c(%r14), %r13
leaq (,%r13,8), %rdi
callq 0x8490
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0xe026b
cmpb $0x0, 0x38(%rsp)
je 0xe02b6
movslq 0x44(%r14), %r12
imulq %r12, %r13
leaq (,%r13,8), %rdi
callq 0x8490
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0xe1473
leaq (,%r12,8), %rdi
callq 0x8490
movq %rax, 0x68(%rsp)
testq %rax, %rax
jne 0xe02cb
shll $0x3, %r12d
leaq 0x4dd9(%rip), %rsi      # 0xe5004
leaq 0x45cee(%rip), %rdx     # 0x125f20
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x2e014
movq 0x8(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
leaq 0x4dda(%rip), %rsi      # 0xe5034
leaq 0x45cac(%rip), %rdx     # 0x125f0d
movl $0x2b4, %ecx            # imm = 0x2B4
jmp 0xe1844
shll $0x3, %r13d
leaq 0x4d8e(%rip), %rsi      # 0xe5004
leaq 0x45c8a(%rip), %rdx     # 0x125f07
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2e014
movq 0x8(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
leaq 0x4d8f(%rip), %rsi      # 0xe5034
leaq 0x45c61(%rip), %rdx     # 0x125f0d
movl $0x2a8, %ecx            # imm = 0x2A8
jmp 0xe1844
movq $0x0, 0x80(%rsp)
movq $0x0, 0x68(%rsp)
movq 0x8(%rsp), %r13
movl 0x5c(%rsp), %edx
cmpl $0x1, %edx
movq %r15, 0x48(%rsp)
movq 0x20(%rsp), %rcx
ja 0xe124d
movabsq $0x6c6e5f62635f6b70, %rax # imm = 0x6C6E5F62635F6B70
xorl %esi, %esi
movl %esi, 0x3c(%rsp)
cmpl 0x64(%r14), %esi
jge 0xe1635
cmpw $0x1, 0x50(%r14)
jne 0xe0334
movl 0x3c(%rsp), %esi
cmpl 0x54(%r14), %esi
jne 0xe0334
testl %edx, %edx
je 0xe0328
movw $0x6c, 0x2c(%rsp)
movl $0x6e5f6b70, 0x28(%rsp) # imm = 0x6E5F6B70
jmp 0xe0334
movb $0x0, 0x2a(%rsp)
movw $0x6b70, 0x28(%rsp)     # imm = 0x6B70
cmpw $0x1, 0x52(%r14)
jne 0xe0365
movl 0x3c(%rsp), %esi
cmpl 0x58(%r14), %esi
jne 0xe0365
testl %edx, %edx
je 0xe0356
movq %rax, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
jmp 0xe0365
movw $0x62, 0x2c(%rsp)
movl $0x635f6b70, 0x28(%rsp) # imm = 0x635F6B70
xorl %edx, %edx
movslq 0xe0(%r13), %rax
cmpq %rax, %rdx
jge 0xe1234
movq %rdx, 0x50(%rsp)
movsd 0xe8(%r13,%rdx,8), %xmm1
movsd 0x818(%rcx), %xmm0
ucomisd %xmm0, %xmm1
ja 0xe175a
cmpl $0x1, %eax
jne 0xe03a9
movb $0x0, 0x11(%rsp)
leaq 0x11(%rsp), %r13
jmp 0xe03e1
movq 0x50(%rsp), %rax
leal 0x1(%rax), %ebx
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45bfe(%rip), %r15     # 0x125fba
movq %r15, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x11(%rsp), %r13
movq %r13, %rdi
movq %r15, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x8580
leaq 0x9bc3(%rip), %rbx      # 0xe9fab
movq %rbx, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46305(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbp
movq %rbp, %rcx
movq %r13, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
movq %rbx, (%rsp)
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rdx
movq %rbp, %rcx
movq %r13, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x8580
movq 0x50(%rsp), %r13
movsd 0xe8(%rbp,%r13,8), %xmm0
movq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
leaq 0x70(%rsp), %rcx
movq %rbx, %r8
leaq 0x472f5(%rip), %r9      # 0x12775c
callq 0xe475d
testl %eax, %eax
jne 0xe17bb
movq %r13, %rdx
cmpb $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %r8d
je 0xe1077
movl 0x40(%r14), %eax
xorl %esi, %esi
pushq $0x2
popq %rcx
xorl %ebx, %ebx
cmpl %eax, %ebx
jge 0xe1077
movl %ecx, 0x8c(%rsp)
movl %esi, 0x78(%rsp)
movl %esi, %ecx
shrl %ecx
negl %ecx
movq %rcx, 0x40(%rsp)
leal 0x1(%rbx), %ecx
movl %ecx, 0x88(%rsp)
movl %ebx, %r13d
movq %rbx, 0x18(%rsp)
cmpl %eax, %r13d
jge 0xe1045
cmpw $0x1, 0x14(%rdi)
jne 0xe057b
movl 0x858(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %r13d, %eax
orl %ecx, %eax
jne 0xe057b
leaq 0x4550a(%rip), %rax     # 0x125a01
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x461f6(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x454cd(%rip), %rax     # 0x125a01
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movups 0x45aab(%rip), %xmm0    # 0x12600f
movaps %xmm0, 0x190(%rsp)
movups 0x45aa5(%rip), %xmm0    # 0x126018
movups %xmm0, 0x199(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe0631
movl 0x860(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %r13d, %eax
orl %ecx, %eax
jne 0xe0631
leaq 0x455d3(%rip), %rax     # 0x125b75
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4614b(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x45596(%rip), %rax     # 0x125b75
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movups 0x45a19(%rip), %xmm0    # 0x126028
movaps %xmm0, 0x190(%rsp)
movups 0x45a1a(%rip), %xmm0    # 0x126038
movaps %xmm0, 0x1a0(%rsp)
movl $0x206564, 0x1af(%rsp) # imm = 0x206564
cmpw $0x1, 0x18(%rdi)
jne 0xe06e4
movl 0x85c(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %r13d, %eax
orl %ecx, %eax
jne 0xe06e4
leaq 0x4555a(%rip), %rax     # 0x125bb2
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46095(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x4551d(%rip), %rax     # 0x125bb2
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movups 0x45986(%rip), %xmm0    # 0x12604b
movaps %xmm0, 0x190(%rsp)
movups 0x45987(%rip), %xmm0    # 0x12605b
movaps %xmm0, 0x1a0(%rsp)
movb $0x0, 0x1b0(%rsp)
cmpw $0x1, 0x1a(%rdi)
jne 0xe079e
movl 0x864(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %r13d, %eax
orl %ecx, %eax
jne 0xe079e
leaq 0x454e6(%rip), %rax     # 0x125bf1
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45fe2(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x454a9(%rip), %rax     # 0x125bf1
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movups 0x458f4(%rip), %xmm0    # 0x12606c
movaps %xmm0, 0x190(%rsp)
movups 0x458f5(%rip), %xmm0    # 0x12607c
movaps %xmm0, 0x1a0(%rsp)
movups 0x458f4(%rip), %xmm0    # 0x12608a
movups %xmm0, 0x1ae(%rsp)
cmpw $0x1, 0x1c(%rdi)
jne 0xe0858
movl 0x868(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %r13d, %eax
orl %ecx, %eax
jne 0xe0858
leaq 0x4546b(%rip), %rax     # 0x125c30
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45f28(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x4542e(%rip), %rax     # 0x125c30
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movups 0x45868(%rip), %xmm0    # 0x12609a
movaps %xmm0, 0x190(%rsp)
movups 0x45869(%rip), %xmm0    # 0x1260aa
movaps %xmm0, 0x1a0(%rsp)
movups 0x45869(%rip), %xmm0    # 0x1260b9
movups %xmm0, 0x1af(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe0b49
cmpw $0x1, 0x16(%rdi)
jne 0xe0920
cmpl 0x858(%rdi), %ebx
jne 0xe0920
cmpl 0x860(%rdi), %r13d
jne 0xe0920
leaq 0x452e4(%rip), %rax     # 0x125b72
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45e5f(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x452a7(%rip), %rax     # 0x125b72
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19e(%rsp)
movups 0x457bc(%rip), %xmm0    # 0x1260c9
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe0b49
cmpw $0x1, 0x18(%rdi)
jne 0xe09dd
cmpl 0x858(%rdi), %ebx
jne 0xe09dd
cmpl 0x85c(%rdi), %r13d
jne 0xe09dd
leaq 0x45264(%rip), %rax     # 0x125baf
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45da2(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x45227(%rip), %rax     # 0x125baf
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19f(%rsp)
movups 0x45715(%rip), %xmm0    # 0x1260df
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe0b49
cmpw $0x1, 0x1a(%rdi)
jne 0xe0a97
cmpl 0x858(%rdi), %ebx
jne 0xe0a97
cmpl 0x864(%rdi), %r13d
jne 0xe0a97
leaq 0x451e6(%rip), %rax     # 0x125bee
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45ce5(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x451a9(%rip), %rax     # 0x125bee
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movups 0x4568f(%rip), %xmm0    # 0x126104
movups %xmm0, 0x19e(%rsp)
movups 0x45672(%rip), %xmm0    # 0x1260f6
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe0b49
cmpw $0x1, 0x1c(%rdi)
jne 0xe0b49
cmpl 0x858(%rdi), %ebx
jne 0xe0b49
cmpl 0x868(%rdi), %r13d
jne 0xe0b49
leaq 0x4516b(%rip), %rax     # 0x125c2d
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45c2b(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x4512e(%rip), %rax     # 0x125c2d
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x19f(%rsp)
movups 0x455d3(%rip), %xmm0    # 0x126114
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe0d80
cmpw $0x1, 0x18(%rdi)
jne 0xe0c11
cmpl 0x860(%rdi), %ebx
jne 0xe0c11
cmpl 0x85c(%rdi), %r13d
jne 0xe0c11
leaq 0x450ed(%rip), %rax     # 0x125c6c
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45b6e(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x450b0(%rip), %rax     # 0x125c6c
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19f(%rsp)
movups 0x4552d(%rip), %xmm0    # 0x12612b
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe0d80
cmpw $0x1, 0x1a(%rdi)
jne 0xe0cce
cmpl 0x860(%rdi), %ebx
jne 0xe0cce
cmpl 0x864(%rdi), %r13d
jne 0xe0cce
leaq 0x4506f(%rip), %rax     # 0x125cab
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45ab1(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x45032(%rip), %rax     # 0x125cab
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2044, %rax # imm = 0x2065646F6D2044
movq %rax, 0x19f(%rsp)
movups 0x45487(%rip), %xmm0    # 0x126142
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe0d80
cmpw $0x1, 0x1c(%rdi)
jne 0xe0d80
cmpl 0x860(%rdi), %ebx
jne 0xe0d80
cmpl 0x868(%rdi), %r13d
jne 0xe0d80
leaq 0x44ff1(%rip), %rax     # 0x125cea
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x459f4(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x44fb4(%rip), %rax     # 0x125cea
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x19f(%rsp)
movups 0x453e1(%rip), %xmm0    # 0x126159
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x18(%rdi)
jne 0xe0efa
cmpw $0x1, 0x1a(%rdi)
jne 0xe0e48
cmpl 0x85c(%rdi), %ebx
jne 0xe0e48
cmpl 0x864(%rdi), %r13d
jne 0xe0e48
leaq 0x44f73(%rip), %rax     # 0x125d29
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x45937(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x44f36(%rip), %rax     # 0x125d29
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2044, %rax # imm = 0x2065646F6D2044
movq %rax, 0x1a0(%rsp)
movups 0x4533b(%rip), %xmm0    # 0x126170
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x18(%rdi)
jne 0xe0efa
cmpw $0x1, 0x1c(%rdi)
jne 0xe0efa
cmpl 0x85c(%rdi), %ebx
jne 0xe0efa
cmpl 0x868(%rdi), %r13d
jne 0xe0efa
leaq 0x44ef7(%rip), %rax     # 0x125d6a
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4587a(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x44eba(%rip), %rax     # 0x125d6a
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x1a0(%rsp)
movups 0x45296(%rip), %xmm0    # 0x126188
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x1a(%rdi)
jne 0xe0fb7
cmpw $0x1, 0x1c(%rdi)
jne 0xe0fb7
cmpl 0x864(%rdi), %ebx
jne 0xe0fb7
cmpl 0x868(%rdi), %r13d
jne 0xe0fb7
leaq 0x44e7b(%rip), %rax     # 0x125dab
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x457bd(%rip), %r12     # 0x1266fc
movq %r12, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
leaq 0x11(%rsp), %r15
movq %r15, %r8
leaq 0x28(%rsp), %rbp
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x44e3e(%rip), %rax     # 0x125dab
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq %r15, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0x8580
movq 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x1a0(%rsp)
movups 0x451f1(%rip), %xmm0    # 0x1261a0
movaps %xmm0, 0x190(%rsp)
movl 0x40(%r14), %eax
cmpl %r13d, %ebx
jbe 0xe0fd6
movl %eax, %edx
imull %r13d, %edx
leal 0x1(%r13), %esi
imull %r13d, %esi
shrl %esi
movl %ebx, %ecx
subl %esi, %ecx
jmp 0xe0fe3
movl %ebx, %ecx
imull %eax, %ecx
movq 0x40(%rsp), %rdx
addl %r13d, %edx
addl %edx, %ecx
movq 0x48(%r14), %rdx
movslq %ecx, %rcx
cmpw $0x1, (%rdx,%rcx,2)
jne 0xe103d
movq 0x68(%rsp), %rax
leaq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rdx
movq 0x50(%rsp), %rax
movsd 0xe8(%rdx,%rax,8), %xmm0
movq 0x48(%rsp), %rdi
movq %r14, %rsi
leaq 0x90(%rsp), %r8
leaq 0x190(%rsp), %r9
callq 0xe475d
testl %eax, %eax
jne 0xe1429
movl 0x40(%r14), %eax
movq 0x20(%rsp), %rdi
incl %r13d
jmp 0xe04c7
movl 0x78(%rsp), %esi
movl 0x8c(%rsp), %ecx
addl %ecx, %esi
addl $0x2, %ecx
movl 0x88(%rsp), %edx
movl %edx, %ebx
movq 0x48(%rsp), %r15
movq 0x8(%rsp), %rbp
movl 0x3c(%rsp), %r8d
movq 0x50(%rsp), %rdx
jmp 0xe0497
movsd 0xe8(%rbp,%rdx,8), %xmm0
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
movl 0x5c(%rsp), %ecx
movq 0x60(%rsp), %r9
callq 0x98198
cmpl $0x1, %eax
je 0xe17fd
movq 0x70(%rsp), %rax
movq %rax, 0x78(%rsp)
xorl %ebp, %ebp
movslq 0x6c(%r14), %rax
cmpq %rax, %rbp
jge 0xe11de
movq 0x80(%r14), %rax
movsd (%rax,%rbp,8), %xmm0
callq 0x86a0
divsd 0x8(%r15), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x60(%rsp), %rax
movsd (%rax,%rbp,8), %xmm0
callq 0x86a0
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r15), %xmm0
movsd 0x5643(%rip), %xmm1     # 0xe6748
callq 0x8650
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq 0x78(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0xe4917
cmpb $0x0, 0x38(%rsp)
je 0xe11d1
movslq %ebp, %r13
xorl %r15d, %r15d
movslq 0x44(%r14), %rax
cmpq %rax, %r15
jge 0xe11d1
movq 0x48(%r14), %rax
cmpw $0x1, (%rax,%r15,2)
jne 0xe11c9
movq 0x68(%rsp), %rax
movq (%rax,%r15,8), %rbx
movq 0x80(%r14), %rax
movsd (%rax,%rbp,8), %xmm0
callq 0x86a0
movq 0x48(%rsp), %r12
divsd 0x8(%r12), %xmm0
movsd %xmm0, 0x18(%rsp)
movslq 0x44(%r14), %rax
imulq %r13, %rax
addq %r15, %rax
movq 0x80(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm0
callq 0x86a0
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r12), %xmm0
movsd 0x559c(%rip), %xmm1     # 0xe6748
callq 0x8650
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0xe4917
incq %r15
jmp 0xe1135
incq %rbp
movq 0x48(%rsp), %r15
jmp 0xe10b8
movq 0x78(%rsp), %rdi
callq 0x83c0
cmpb $0x0, 0x38(%rsp)
movq 0x8(%rsp), %r13
movq 0x20(%rsp), %rcx
je 0xe1227
xorl %ebx, %ebx
movslq 0x44(%r14), %rax
cmpq %rax, %rbx
jge 0xe1227
movq 0x48(%r14), %rax
cmpw $0x1, (%rax,%rbx,2)
jne 0xe1222
movq 0x68(%rsp), %rax
movq (%rax,%rbx,8), %rdi
callq 0x83c0
movq 0x20(%rsp), %rcx
incq %rbx
jmp 0xe11fb
movq 0x50(%rsp), %rdx
incq %rdx
jmp 0xe0367
movl 0x3c(%rsp), %esi
incl %esi
movl 0x5c(%rsp), %edx
movabsq $0x6c6e5f62635f6b70, %rax # imm = 0x6C6E5F62635F6B70
jmp 0xe02f3
cmpl $0x3, %edx
je 0xe14be
cmpl $0x2, %edx
jne 0xe1560
leaq 0x11(%rsp), %rbp
xorl %edx, %edx
movslq 0xe0(%r13), %rax
cmpq %rax, %rdx
jge 0xe1635
movsd 0xe8(%r13,%rdx,8), %xmm1
movsd 0x818(%rcx), %xmm0
ucomisd %xmm0, %xmm1
ja 0xe1668
cmpl $0x1, %eax
movq %rdx, 0x50(%rsp)
jne 0xe12a3
movb $0x0, 0x11(%rsp)
jmp 0xe12e0
leal 0x1(%rdx), %r13d
xorl %edi, %edi
xorl %esi, %esi
leaq 0x44d08(%rip), %rbx     # 0x125fba
movq %rbx, %rdx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x11(%rsp), %rdi
movq %rbx, %rdx
movl %r13d, %ecx
movq 0x8(%rsp), %r13
xorl %eax, %eax
callq 0x8580
leaq 0x11(%rsp), %rbp
xorl %edi, %edi
xorl %esi, %esi
leaq 0x44f9b(%rip), %r12     # 0x126286
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
movq %r13, %rbx
leaq 0x90(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x8580
movq 0x50(%rsp), %r12
movsd 0xe8(%rbx,%r12,8), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq 0x70(%rsp), %rcx
movq %r13, %r8
leaq 0x46417(%rip), %r9      # 0x12775c
callq 0xe475d
testl %eax, %eax
jne 0xe16c6
movq %r12, %rbp
movsd 0xe8(%rbx,%r12,8), %xmm0
andq $0x0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
xorl %r8d, %r8d
movq 0x60(%rsp), %r9
callq 0x98198
cmpl $0x1, %eax
je 0xe170b
movq 0x70(%rsp), %r13
xorl %r15d, %r15d
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jge 0xe1402
movq 0x80(%r14), %rax
movsd (%rax,%r15,8), %xmm0
callq 0x86a0
movq 0x48(%rsp), %r12
divsd 0x8(%r12), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x60(%rsp), %rax
movsd (%rax,%r15,8), %xmm0
callq 0x86a0
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r12), %xmm0
movsd 0x5368(%rip), %xmm1     # 0xe6748
callq 0x8650
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %r13, %rdi
movsd 0x18(%rsp), %xmm0
callq 0xe4917
incq %r15
jmp 0xe138e
movq %r13, %rdi
callq 0x83c0
movq %rbp, %rdx
incq %rdx
movq 0x48(%rsp), %r15
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %r13
leaq 0x11(%rsp), %rbp
jmp 0xe1266
movq 0x8(%rsp), %r14
addq $0x420, %r14            # imm = 0x420
leaq 0x3fb4(%rip), %rsi      # 0xe53f0
leaq 0x44d75(%rip), %rdx     # 0x1261b8
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3bd5(%rip), %rsi      # 0xe5034
leaq 0x44aa7(%rip), %rdx     # 0x125f0d
movq %r14, %rdi
movl $0x348, %ecx            # imm = 0x348
jmp 0xe1844
shll $0x3, %r13d
leaq 0x3b86(%rip), %rsi      # 0xe5004
leaq 0x44a92(%rip), %rdx     # 0x125f17
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2e014
movq 0x8(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
leaq 0x3b87(%rip), %rsi      # 0xe5034
leaq 0x44a59(%rip), %rdx     # 0x125f0d
movl $0x2ae, %ecx            # imm = 0x2AE
jmp 0xe1844
leaq 0x44e2c(%rip), %rbx     # 0x1262f1
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x8580
incl %eax
movslq %eax, %rsi
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x8580
leaq 0x46262(%rip), %r9      # 0x12775c
leaq 0x70(%rsp), %rcx
xorps %xmm0, %xmm0
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %r8
callq 0xe475d
testl %eax, %eax
je 0xe15b7
addq $0x420, %r13            # imm = 0x420
leaq 0x3ec7(%rip), %rsi      # 0xe53f0
leaq 0x44ddc(%rip), %rdx     # 0x12630c
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3ae8(%rip), %rsi      # 0xe5034
leaq 0x449ba(%rip), %rdx     # 0x125f0d
movq %r13, %rdi
movl $0x3db, %ecx            # imm = 0x3DB
jmp 0xe1844
leaq 0x44de5(%rip), %rsi     # 0x12634c
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0x4005(%rip), %rsi      # 0xe5585
leaq 0xd90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2e014
addq $0x420, %r13            # imm = 0x420
leaq 0x3a91(%rip), %rsi      # 0xe5034
leaq 0x44963(%rip), %rdx     # 0x125f0d
movq %r13, %rdi
movl $0x3eb, %ecx            # imm = 0x3EB
jmp 0xe17b3
movq 0x70(%rsp), %rbx
xorl %r15d, %r15d
movq 0x48(%rsp), %r12
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jge 0xe162d
movq 0x78(%r14), %rax
movq 0x118(%r14), %rcx
movsd (%rax,%r15,8), %xmm0
divsd 0x8(%r12), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%rcx,%r15,8), %xmm0
callq 0x86a0
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r12), %xmm0
movsd 0x513d(%rip), %xmm1     # 0xe6748
callq 0x8650
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0xe4917
incq %r15
jmp 0xe15c4
movq %rbx, %rdi
callq 0x83c0
movq 0x60(%rsp), %rdi
callq 0x8430
xorl %ebx, %ebx
cmpb $0x0, 0x38(%rsp)
je 0xe1851
movq 0x80(%rsp), %rdi
callq 0x8430
movq 0x68(%rsp), %rdi
callq 0x8430
jmp 0xe1851
leaq 0x448ca(%rip), %rsi     # 0x125f39
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x39fa(%rip), %rsi      # 0xe5082
leaq 0x44906(%rip), %rdx     # 0x125f95
leaq 0xd90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x420, %r13            # imm = 0x420
leaq 0x3982(%rip), %rsi      # 0xe5034
leaq 0x44854(%rip), %rdx     # 0x125f0d
movq %r13, %rdi
movl $0x393, %ecx            # imm = 0x393
jmp 0xe17b3
addq $0x420, %rbx            # imm = 0x420
leaq 0x3d1c(%rip), %rsi      # 0xe53f0
leaq 0x448e4(%rip), %rdx     # 0x125fbf
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x393d(%rip), %rsi      # 0xe5034
leaq 0x4480f(%rip), %rdx     # 0x125f0d
movq %rbx, %rdi
movl $0x3a7, %ecx            # imm = 0x3A7
jmp 0xe17b3
movq %rbx, %r15
addq $0x192, %r14            # imm = 0x192
leaq 0x3cd4(%rip), %rsi      # 0xe53f0
leaq 0x44b71(%rip), %rdx     # 0x126294
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x420, %r15            # imm = 0x420
leaq 0x38ee(%rip), %rsi      # 0xe5034
leaq 0x447c0(%rip), %rdx     # 0x125f0d
movq %r15, %rdi
movl $0x3b5, %ecx            # imm = 0x3B5
jmp 0xe1844
leaq 0x447d8(%rip), %rsi     # 0x125f39
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movb $0x2, %al
callq 0x2e014
leaq 0x3908(%rip), %rsi      # 0xe5082
leaq 0x44814(%rip), %rdx     # 0x125f95
leaq 0xd90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x420, %r13            # imm = 0x420
leaq 0x3890(%rip), %rsi      # 0xe5034
leaq 0x44762(%rip), %rdx     # 0x125f0d
movq %r13, %rdi
movl $0x2d4, %ecx            # imm = 0x2D4
movq %r14, %r8
jmp 0xe1847
addq $0x420, %rbp            # imm = 0x420
leaq 0x3c27(%rip), %rsi      # 0xe53f0
leaq 0x447ef(%rip), %rdx     # 0x125fbf
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0x3848(%rip), %rsi      # 0xe5034
leaq 0x4471a(%rip), %rdx     # 0x125f0d
movq %rbp, %rdi
movl $0x2e8, %ecx            # imm = 0x2E8
jmp 0xe1844
addq $0x192, %r14            # imm = 0x192
leaq 0x3be5(%rip), %rsi      # 0xe53f0
leaq 0x44a12(%rip), %rdx     # 0x126224
leaq 0x590(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x420, %rbp            # imm = 0x420
leaq 0x37ff(%rip), %rsi      # 0xe5034
leaq 0x446d1(%rip), %rdx     # 0x125f0d
movq %rbp, %rdi
movl $0x35a, %ecx            # imm = 0x35A
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x1598, %rsp           # imm = 0x1598
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq