// File: /workspace/github_c_makefile_star2_O3/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, 0x20(%rsp)
movq %rdi, %rbx
movl %r8d, 0x4c(%rsp)
movq %rcx, %r15
testl %r8d, %r8d
je 0xe8845
movl $0x0, 0x38(%rsp)
jmp 0xe8852
cmpl $0x2, 0x40(%r12)
setge %al
movl %eax, 0x38(%rsp)
movslq 0x6c(%r12), %r13
leaq (,%r13,8), %rdi
callq 0x8460
testq %rax, %rax
je 0xe8906
cmpb $0x0, 0x38(%rsp)
movq %rax, 0x58(%rsp)
je 0xe894f
movslq 0x44(%r12), %rbp
imulq %rbp, %r13
leaq (,%r13,8), %rdi
callq 0x8460
movq %rax, 0x88(%rsp)
testq %rax, %rax
je 0xe9ae6
leaq (,%rbp,8), %rdi
callq 0x8460
movq %rax, 0x60(%rsp)
testq %rax, %rax
jne 0xe8964
shll $0x3, %ebp
leaq 0x573b(%rip), %rsi      # 0xee004
leaq 0x467e0(%rip), %rdx     # 0x12f0b0
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x420, %r15            # imm = 0x420
leaq 0x5742(%rip), %rsi      # 0xee034
leaq 0x467a4(%rip), %rdx     # 0x12f09d
movq %r15, %rdi
movl $0x2b4, %ecx            # imm = 0x2B4
jmp 0xe9e76
shll $0x3, %r13d
leaq 0x56f3(%rip), %rsi      # 0xee004
leaq 0x4677f(%rip), %rdx     # 0x12f097
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x420, %r15            # imm = 0x420
leaq 0x56f9(%rip), %rsi      # 0xee034
leaq 0x4675b(%rip), %rdx     # 0x12f09d
movq %r15, %rdi
movl $0x2a8, %ecx            # imm = 0x2A8
jmp 0xe9e76
movq $0x0, 0x88(%rsp)
movq $0x0, 0x60(%rsp)
movl 0x4c(%rsp), %edx
cmpl $0x1, %edx
movq 0x20(%rsp), %rsi
ja 0xe9903
movq %rbx, 0x50(%rsp)
movl 0x64(%r12), %eax
testl %eax, %eax
jle 0xe9cfc
leaq 0x9(%rsp), %rbp
movl $0x0, 0x3c(%rsp)
movq %r15, 0x18(%rsp)
cmpw $0x1, 0x50(%r12)
jne 0xe89d2
movl 0x3c(%rsp), %ecx
cmpl 0x54(%r12), %ecx
jne 0xe89d2
cmpl $0x0, 0x4c(%rsp)
je 0xe89c6
movw $0x6c, 0x2c(%rsp)
movl $0x6e5f6b70, 0x28(%rsp) # imm = 0x6E5F6B70
jmp 0xe89d2
movb $0x0, 0x2a(%rsp)
movw $0x6b70, 0x28(%rsp)     # imm = 0x6B70
cmpw $0x1, 0x52(%r12)
jne 0xe8a12
movl 0x3c(%rsp), %ecx
cmpl 0x58(%r12), %ecx
jne 0xe8a12
cmpl $0x0, 0x4c(%rsp)
je 0xe8a03
movabsq $0x6c6e5f62635f6b70, %rcx # imm = 0x6C6E5F62635F6B70
movq %rcx, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
jmp 0xe8a12
movw $0x62, 0x2c(%rsp)
movl $0x635f6b70, 0x28(%rsp) # imm = 0x635F6B70
movl 0xe0(%r15), %ecx
testl %ecx, %ecx
jle 0xe98ec
xorl %eax, %eax
movsd 0xe8(%r15,%rax,8), %xmm1
movsd 0x818(%rsi), %xmm0
ucomisd %xmm0, %xmm1
ja 0xe9d2f
cmpl $0x1, %ecx
movq %rax, 0x78(%rsp)
jne 0xe8a50
movb $0x0, 0x9(%rsp)
jmp 0xe8a85
leal 0x1(%rax), %ebp
xorl %edi, %edi
xorl %esi, %esi
leaq 0x466ec(%rip), %rbx     # 0x12f14a
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 0xa657(%rip), %r14      # 0xf30e3
movq %r14, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46df1(%rip), %r13     # 0x12f88c
movq %r13, %rdx
movq 0x18(%rsp), %r15
movq %r15, %rcx
movq %rbp, %r8
leaq 0x28(%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 0x78(%rsp), %rax
movsd 0xe8(%r15,%rax,8), %xmm0
movq 0x50(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
movq %r14, %r8
leaq 0x47de4(%rip), %r9      # 0x1308ec
callq 0xecf81
testl %eax, %eax
jne 0xe9d90
cmpb $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
je 0xe96d2
movl 0x40(%r12), %eax
testl %eax, %eax
jle 0xe96d2
movl $0x2, %ecx
movl $0x0, 0x74(%rsp)
xorl %ebx, %ebx
movl %ecx, 0x80(%rsp)
cmpl %eax, %ebx
jge 0xe96ba
movl 0x74(%rsp), %eax
shrl %eax
negl %eax
movq %rax, 0x40(%rsp)
movl %ebx, %ebp
movl %ebx, 0x10(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe8c0c
movl 0x858(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xe8c0c
leaq 0x46008(%rip), %rax     # 0x12eb91
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46cf4(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45fcb(%rip), %rax     # 0x12eb91
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 0x20(%rsp), %rdi
movups 0x465aa(%rip), %xmm0    # 0x12f19f
movaps %xmm0, 0x190(%rsp)
movups 0x465a4(%rip), %xmm0    # 0x12f1a8
movups %xmm0, 0x199(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe8cc0
movl 0x860(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xe8cc0
leaq 0x460d3(%rip), %rax     # 0x12ed05
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46c4b(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x46096(%rip), %rax     # 0x12ed05
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 0x20(%rsp), %rdi
movups 0x4651a(%rip), %xmm0    # 0x12f1b8
movaps %xmm0, 0x190(%rsp)
movups 0x4651b(%rip), %xmm0    # 0x12f1c8
movaps %xmm0, 0x1a0(%rsp)
movl $0x206564, 0x1af(%rsp) # imm = 0x206564
cmpw $0x1, 0x18(%rdi)
jne 0xe8d71
movl 0x85c(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xe8d71
leaq 0x4605c(%rip), %rax     # 0x12ed42
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46b97(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x4601f(%rip), %rax     # 0x12ed42
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 0x20(%rsp), %rdi
movups 0x46489(%rip), %xmm0    # 0x12f1db
movaps %xmm0, 0x190(%rsp)
movups 0x4648a(%rip), %xmm0    # 0x12f1eb
movaps %xmm0, 0x1a0(%rsp)
movb $0x0, 0x1b0(%rsp)
cmpw $0x1, 0x1a(%rdi)
jne 0xe8e29
movl 0x864(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xe8e29
leaq 0x45fea(%rip), %rax     # 0x12ed81
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46ae6(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45fad(%rip), %rax     # 0x12ed81
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 0x20(%rsp), %rdi
movups 0x463f9(%rip), %xmm0    # 0x12f1fc
movaps %xmm0, 0x190(%rsp)
movups 0x463fa(%rip), %xmm0    # 0x12f20c
movaps %xmm0, 0x1a0(%rsp)
movups 0x463f9(%rip), %xmm0    # 0x12f21a
movups %xmm0, 0x1ae(%rsp)
cmpw $0x1, 0x1c(%rdi)
jne 0xe8ee1
movl 0x868(%rdi), %eax
movl %ebx, %ecx
xorl %eax, %ecx
xorl %ebp, %eax
orl %ecx, %eax
jne 0xe8ee1
leaq 0x45f71(%rip), %rax     # 0x12edc0
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46a2e(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45f34(%rip), %rax     # 0x12edc0
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 0x20(%rsp), %rdi
movups 0x4636f(%rip), %xmm0    # 0x12f22a
movaps %xmm0, 0x190(%rsp)
movups 0x46370(%rip), %xmm0    # 0x12f23a
movaps %xmm0, 0x1a0(%rsp)
movups 0x46370(%rip), %xmm0    # 0x12f249
movups %xmm0, 0x1af(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe91ca
cmpw $0x1, 0x16(%rdi)
jne 0xe8fa7
cmpl 0x858(%rdi), %ebx
jne 0xe8fa7
cmpl 0x860(%rdi), %ebp
jne 0xe8fa7
leaq 0x45dec(%rip), %rax     # 0x12ed02
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46967(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45daf(%rip), %rax     # 0x12ed02
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19e(%rsp)
movups 0x462c5(%rip), %xmm0    # 0x12f259
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe91ca
cmpw $0x1, 0x18(%rdi)
jne 0xe9062
cmpl 0x858(%rdi), %ebx
jne 0xe9062
cmpl 0x85c(%rdi), %ebp
jne 0xe9062
leaq 0x45d6e(%rip), %rax     # 0x12ed3f
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x468ac(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45d31(%rip), %rax     # 0x12ed3f
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19f(%rsp)
movups 0x46220(%rip), %xmm0    # 0x12f26f
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe91ca
cmpw $0x1, 0x1a(%rdi)
jne 0xe911a
cmpl 0x858(%rdi), %ebx
jne 0xe911a
cmpl 0x864(%rdi), %ebp
jne 0xe911a
leaq 0x45cf2(%rip), %rax     # 0x12ed7e
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x467f1(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45cb5(%rip), %rax     # 0x12ed7e
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 0x20(%rsp), %rdi
movups 0x4619c(%rip), %xmm0    # 0x12f294
movups %xmm0, 0x19e(%rsp)
movups 0x4617f(%rip), %xmm0    # 0x12f286
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x14(%rdi)
jne 0xe91ca
cmpw $0x1, 0x1c(%rdi)
jne 0xe91ca
cmpl 0x858(%rdi), %ebx
jne 0xe91ca
cmpl 0x868(%rdi), %ebp
jne 0xe91ca
leaq 0x45c79(%rip), %rax     # 0x12edbd
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46739(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45c3c(%rip), %rax     # 0x12edbd
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x19f(%rsp)
movups 0x460e2(%rip), %xmm0    # 0x12f2a4
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe93fb
cmpw $0x1, 0x18(%rdi)
jne 0xe9290
cmpl 0x860(%rdi), %ebx
jne 0xe9290
cmpl 0x85c(%rdi), %ebp
jne 0xe9290
leaq 0x45bfd(%rip), %rax     # 0x12edfc
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4667e(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45bc0(%rip), %rax     # 0x12edfc
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2049, %rax # imm = 0x2065646F6D2049
movq %rax, 0x19f(%rsp)
movups 0x4603e(%rip), %xmm0    # 0x12f2bb
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe93fb
cmpw $0x1, 0x1a(%rdi)
jne 0xe934b
cmpl 0x860(%rdi), %ebx
jne 0xe934b
cmpl 0x864(%rdi), %ebp
jne 0xe934b
leaq 0x45b81(%rip), %rax     # 0x12ee3b
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x465c3(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45b44(%rip), %rax     # 0x12ee3b
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2044, %rax # imm = 0x2065646F6D2044
movq %rax, 0x19f(%rsp)
movups 0x45f9a(%rip), %xmm0    # 0x12f2d2
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x16(%rdi)
jne 0xe93fb
cmpw $0x1, 0x1c(%rdi)
jne 0xe93fb
cmpl 0x860(%rdi), %ebx
jne 0xe93fb
cmpl 0x868(%rdi), %ebp
jne 0xe93fb
leaq 0x45b05(%rip), %rax     # 0x12ee7a
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46508(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45ac8(%rip), %rax     # 0x12ee7a
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x19f(%rsp)
movups 0x45ef6(%rip), %xmm0    # 0x12f2e9
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x18(%rdi)
jne 0xe9571
cmpw $0x1, 0x1a(%rdi)
jne 0xe94c1
cmpl 0x85c(%rdi), %ebx
jne 0xe94c1
cmpl 0x864(%rdi), %ebp
jne 0xe94c1
leaq 0x45a89(%rip), %rax     # 0x12eeb9
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x4644d(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45a4c(%rip), %rax     # 0x12eeb9
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2044, %rax # imm = 0x2065646F6D2044
movq %rax, 0x1a0(%rsp)
movups 0x45e52(%rip), %xmm0    # 0x12f300
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x18(%rdi)
jne 0xe9571
cmpw $0x1, 0x1c(%rdi)
jne 0xe9571
cmpl 0x85c(%rdi), %ebx
jne 0xe9571
cmpl 0x868(%rdi), %ebp
jne 0xe9571
leaq 0x45a0f(%rip), %rax     # 0x12eefa
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x46392(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x459d2(%rip), %rax     # 0x12eefa
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x1a0(%rsp)
movups 0x45daf(%rip), %xmm0    # 0x12f318
movaps %xmm0, 0x190(%rsp)
cmpw $0x1, 0x1a(%rdi)
jne 0xe962c
cmpw $0x1, 0x1c(%rdi)
jne 0xe962c
cmpl 0x864(%rdi), %ebx
jne 0xe962c
cmpl 0x868(%rdi), %ebp
jne 0xe962c
leaq 0x45995(%rip), %rax     # 0x12ef3b
movq %rax, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
leaq 0x462d7(%rip), %r14     # 0x12f88c
movq %r14, %rdx
movq 0x18(%rsp), %r13
movq %r13, %rcx
leaq 0x9(%rsp), %rbx
movq %rbx, %r8
leaq 0x28(%rsp), %r15
movq %r15, %r9
xorl %eax, %eax
callq 0x8550
incl %eax
movslq %eax, %rsi
leaq 0x45958(%rip), %rax     # 0x12ef3b
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 0x20(%rsp), %rdi
movabsq $0x2065646f6d2056, %rax # imm = 0x2065646F6D2056
movq %rax, 0x1a0(%rsp)
movups 0x45d0c(%rip), %xmm0    # 0x12f330
movaps %xmm0, 0x190(%rsp)
movl 0x40(%r12), %eax
cmpl %ebp, %ebx
jbe 0xe9648
movl %eax, %edx
imull %ebp, %edx
leal 0x1(%rbp), %esi
imull %ebp, %esi
shrl %esi
movl %ebx, %ecx
subl %esi, %ecx
jmp 0xe9654
movl %ebx, %ecx
imull %eax, %ecx
movq 0x40(%rsp), %rdx
addl %ebp, %edx
addl %edx, %ecx
movq 0x48(%r12), %rdx
movslq %ecx, %rcx
cmpw $0x1, (%rdx,%rcx,2)
jne 0xe96b0
movq 0x60(%rsp), %rax
leaq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rdx
movq 0x78(%rsp), %rax
movsd 0xe8(%rdx,%rax,8), %xmm0
movq 0x50(%rsp), %rdi
movq %r12, %rsi
leaq 0x90(%rsp), %r8
leaq 0x190(%rsp), %r9
callq 0xecf81
testl %eax, %eax
jne 0xe9b2f
movl 0x40(%r12), %eax
movq 0x20(%rsp), %rdi
incl %ebp
cmpl %eax, %ebp
jl 0xe8b63
incl %ebx
movl 0x80(%rsp), %ecx
addl %ecx, 0x74(%rsp)
addl $0x2, %ecx
cmpl %eax, %ebx
jl 0xe8b41
movq 0x18(%rsp), %rax
movq 0x78(%rsp), %rcx
movsd 0xe8(%rax,%rcx,8), %xmm0
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
movq %r12, %rsi
movl $0x1, %edx
movl 0x4c(%rsp), %ecx
movl 0x3c(%rsp), %r8d
movq 0x58(%rsp), %r9
callq 0x9d04c
cmpl $0x1, %eax
je 0xe9ee8
cmpl $0x0, 0x6c(%r12)
movq 0x68(%rsp), %rax
movq %rax, 0x80(%rsp)
jle 0xe9872
xorl %ebx, %ebx
movq 0x80(%r12), %rax
movsd (%rax,%rbx,8), %xmm0
callq 0x8670
movq 0x50(%rsp), %r15
divsd 0x8(%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x58(%rsp), %rax
movsd (%rax,%rbx,8), %xmm0
callq 0x8670
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r15), %xmm0
movsd 0x5f05(%rip), %xmm1     # 0xef680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq 0x80(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0xed147
cmpb $0x0, 0x38(%rsp)
je 0xe9861
movl 0x44(%r12), %eax
testl %eax, %eax
jle 0xe9861
movslq %ebx, %r13
xorl %r15d, %r15d
movq 0x48(%r12), %rcx
cmpw $0x1, (%rcx,%r15,2)
jne 0xe9852
movq 0x60(%rsp), %rax
movq (%rax,%r15,8), %rbp
movq 0x80(%r12), %rax
movsd (%rax,%rbx,8), %xmm0
callq 0x8670
movq %r12, %r14
movq 0x50(%rsp), %r12
divsd 0x8(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0x44(%r14), %rax
imulq %r13, %rax
addq %r15, %rax
movq 0x88(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm0
callq 0x8670
movsd %xmm0, 0x40(%rsp)
movsd 0x8(%r12), %xmm0
movq %r14, %r12
movsd 0x5e4f(%rip), %xmm1     # 0xef680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %rbp, %rdi
movsd 0x10(%rsp), %xmm0
callq 0xed147
movl 0x44(%r14), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0xe97bb
incq %rbx
movslq 0x6c(%r12), %rax
cmpq %rax, %rbx
jl 0xe9735
movq 0x80(%rsp), %rdi
callq 0x83a0
cmpb $0x0, 0x38(%rsp)
movq 0x18(%rsp), %r15
movq 0x20(%rsp), %rsi
leaq 0x9(%rsp), %rbp
je 0xe98cf
movl 0x44(%r12), %eax
testl %eax, %eax
jle 0xe98cf
xorl %ebx, %ebx
movq 0x48(%r12), %rcx
cmpw $0x1, (%rcx,%rbx,2)
jne 0xe98c4
movq 0x60(%rsp), %rax
movq (%rax,%rbx,8), %rdi
callq 0x83a0
movq 0x20(%rsp), %rsi
movl 0x44(%r12), %eax
incq %rbx
movslq %eax, %rcx
cmpq %rcx, %rbx
jl 0xe98a0
movq 0x78(%rsp), %rax
incq %rax
movslq 0xe0(%r15), %rcx
cmpq %rcx, %rax
jl 0xe8a23
movl 0x64(%r12), %eax
movl 0x3c(%rsp), %ecx
incl %ecx
movl %ecx, 0x3c(%rsp)
cmpl %eax, %ecx
jl 0xe899a
jmp 0xe9cfc
cmpl $0x3, %edx
je 0xe9b79
cmpl $0x2, %edx
jne 0xe9c1e
movl 0xe0(%r15), %eax
testl %eax, %eax
jle 0xe9cfc
leaq 0x9(%rsp), %rbp
xorl %ecx, %ecx
movsd 0xe8(%r15,%rcx,8), %xmm1
movsd 0x818(%rsi), %xmm0
ucomisd %xmm0, %xmm1
ja 0xe9dd5
cmpl $0x1, %eax
movq %rcx, 0x50(%rsp)
jne 0xe9958
movb $0x0, 0x9(%rsp)
jmp 0xe9989
leal 0x1(%rcx), %r13d
xorl %edi, %edi
xorl %esi, %esi
leaq 0x457e3(%rip), %r14     # 0x12f14a
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 0x45a82(%rip), %r14     # 0x12f416
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 0x50(%rsp), %r14
movsd 0xe8(%r15,%r14,8), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x68(%rsp), %rcx
movq %r13, %r8
leaq 0x46f01(%rip), %r9      # 0x1308ec
callq 0xecf81
testl %eax, %eax
jne 0xe9e36
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 0x58(%rsp), %r9
callq 0x9d04c
cmpl $0x1, %eax
je 0xe9e99
cmpl $0x0, 0x6c(%r12)
movq 0x68(%rsp), %r13
movq %r12, %r14
movq %rbx, %r12
movq 0x58(%rsp), %rbp
jle 0xe9ab1
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 0x5bf8(%rip), %xmm1     # 0xef680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %r13, %rdi
movsd 0x10(%rsp), %xmm0
callq 0xed147
incq %rbx
movslq 0x6c(%r14), %rax
cmpq %rax, %rbx
jl 0xe9a4a
movq %r13, %rdi
callq 0x83a0
movq 0x50(%rsp), %rcx
incq %rcx
movslq 0xe0(%r15), %rax
cmpq %rax, %rcx
movq %r12, %rbx
movq %r14, %r12
movq 0x20(%rsp), %rsi
leaq 0x9(%rsp), %rbp
jl 0xe992b
jmp 0xe9cfc
shll $0x3, %r13d
leaq 0x4513(%rip), %rsi      # 0xee004
leaq 0x455af(%rip), %rdx     # 0x12f0a7
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30af0
addq $0x420, %r15            # imm = 0x420
leaq 0x4519(%rip), %rsi      # 0xee034
leaq 0x4557b(%rip), %rdx     # 0x12f09d
movq %r15, %rdi
movl $0x2ae, %ecx            # imm = 0x2AE
jmp 0xe9e76
movq 0x18(%rsp), %rbx
addq $0x420, %rbx            # imm = 0x420
leaq 0x48ae(%rip), %rsi      # 0xee3f0
leaq 0x457ff(%rip), %rdx     # 0x12f348
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x44cf(%rip), %rsi      # 0xee034
leaq 0x45531(%rip), %rdx     # 0x12f09d
movq %rbx, %rdi
movl $0x348, %ecx            # imm = 0x348
jmp 0xe9e76
movq %r12, %r14
leaq 0x458fe(%rip), %r12     # 0x12f481
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 0x46d34(%rip), %r9      # 0x1308ec
leaq 0x68(%rsp), %rcx
xorps %xmm0, %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %r8
callq 0xecf81
testl %eax, %eax
je 0xe9c7b
addq $0x420, %r15            # imm = 0x420
leaq 0x4809(%rip), %rsi      # 0xee3f0
leaq 0x458ae(%rip), %rdx     # 0x12f49c
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x442a(%rip), %rsi      # 0xee034
leaq 0x4548c(%rip), %rdx     # 0x12f09d
movq %r15, %rdi
movl $0x3db, %ecx            # imm = 0x3DB
jmp 0xe9e76
leaq 0x458b7(%rip), %rsi     # 0x12f4dc
leaq 0x590(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0x4947(%rip), %rsi      # 0xee585
movq %r15, %rbx
leaq 0xd90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30af0
addq $0x420, %rbx            # imm = 0x420
leaq 0x43d0(%rip), %rsi      # 0xee034
leaq 0x45432(%rip), %rdx     # 0x12f09d
movq %rbx, %rdi
movl $0x3eb, %ecx            # imm = 0x3EB
movq %r15, %r8
jmp 0xe9e79
cmpl $0x0, 0x6c(%r14)
movq %rbx, %r12
movq 0x68(%rsp), %rbx
jle 0xe9cf4
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 0x59b5(%rip), %xmm1     # 0xef680
callq 0x8620
movsd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0xed147
incq %r15
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jl 0xe9c8d
movq %rbx, %rdi
callq 0x83a0
movq 0x58(%rsp), %rdi
callq 0x8410
xorl %ebx, %ebx
cmpb $0x0, 0x38(%rsp)
je 0xe9e85
movq 0x88(%rsp), %rdi
callq 0x8410
movq 0x60(%rsp), %rdi
callq 0x8410
jmp 0xe9e85
leaq 0x45393(%rip), %rsi     # 0x12f0c9
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x4333(%rip), %rsi      # 0xee082
leaq 0x453cf(%rip), %rdx     # 0x12f125
movq %r15, %rbx
leaq 0xd90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x420, %rbx            # imm = 0x420
leaq 0x42b8(%rip), %rsi      # 0xee034
leaq 0x4531a(%rip), %rdx     # 0x12f09d
movq %rbx, %rdi
movl $0x2d4, %ecx            # imm = 0x2D4
jmp 0xe9c73
addq $0x420, %r15            # imm = 0x420
leaq 0x4652(%rip), %rsi      # 0xee3f0
leaq 0x453aa(%rip), %rdx     # 0x12f14f
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x4273(%rip), %rsi      # 0xee034
leaq 0x452d5(%rip), %rdx     # 0x12f09d
movq %r15, %rdi
movl $0x2e8, %ecx            # imm = 0x2E8
jmp 0xe9e76
leaq 0x452ed(%rip), %rsi     # 0x12f0c9
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x30af0
leaq 0x428d(%rip), %rsi      # 0xee082
leaq 0x45329(%rip), %rdx     # 0x12f125
movq %r15, %rbx
leaq 0xd90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x420, %rbx            # imm = 0x420
leaq 0x4212(%rip), %rsi      # 0xee034
leaq 0x45274(%rip), %rdx     # 0x12f09d
movq %rbx, %rdi
movl $0x393, %ecx            # imm = 0x393
jmp 0xe9c73
addq $0x420, %r15            # imm = 0x420
leaq 0x45ac(%rip), %rsi      # 0xee3f0
leaq 0x45304(%rip), %rdx     # 0x12f14f
leaq 0x590(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0x41cd(%rip), %rsi      # 0xee034
leaq 0x4522f(%rip), %rdx     # 0x12f09d
movq %r15, %rdi
movl $0x3a7, %ecx            # imm = 0x3A7
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
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 0x4549(%rip), %rsi      # 0xee3f0
leaq 0x45576(%rip), %rdx     # 0x12f424
movq %r15, %rbx
leaq 0x590(%rsp), %r15
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x420, %rbx            # imm = 0x420
leaq 0x4160(%rip), %rsi      # 0xee034
leaq 0x451c2(%rip), %rdx     # 0x12f09d
movq %rbx, %rdi
movl $0x3b5, %ecx            # imm = 0x3B5
jmp 0xe9c73
addq $0x192, %r12            # imm = 0x192
leaq 0x44fa(%rip), %rsi      # 0xee3f0
leaq 0x454b7(%rip), %rdx     # 0x12f3b4
leaq 0x590(%rsp), %r15
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x30af0
movq 0x18(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
leaq 0x410f(%rip), %rsi      # 0xee034
leaq 0x45171(%rip), %rdx     # 0x12f09d
movl $0x35a, %ecx            # imm = 0x35A
jmp 0xe9c73