// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/thermodynamics.c
// Function: thermodynamics_set_parameters_reionization
int thermodynamics_set_parameters_reionization(
                                               struct precision * ppr,
                                               struct background * pba,
                                               struct thermodynamics * pth,
                                               struct thermo_reionization_parameters * preio
                                               ) {

  /** Summary: */

  /** Define local variables */
  int bin;
  int point;
  double xe_input,xe_actual,z_sup;

  /** - allocate the vector of parameters defining the function \f$ X_e(z) \f$ */
  class_alloc(preio->reionization_parameters,preio->re_size*sizeof(double),pth->error_message);

  class_test(ppr->reionization_sampling <= 0.0,
             pth->error_message,
             "stop to avoid division by zero. Reionization stepsize has to be larger than zero");

  switch (pth->reio_parametrization) {

    /** - (a) no reionization */
  case reio_none:
    preio->reionization_parameters[preio->index_re_reio_start] = 0.;
    break;

    /** - (b) if reionization implemented like in CAMB, or half tanh like in  1209.0247 */
  case reio_camb:
  case reio_half_tanh:

    /** - --> set values of these parameters, excepted those depending on the reionization redshift */

    if (pth->reio_parametrization == reio_camb) {
      /* xe_after_reio: H + singly ionized He (checked before that denominator is non-zero) */
      preio->reionization_parameters[preio->index_re_xe_after] = 1. + pth->YHe/(_not4_*(1.-pth->YHe));
    }
    if (pth->reio_parametrization == reio_half_tanh) {
      /* xe_after_reio: neglect He ionization */
      preio->reionization_parameters[preio->index_re_xe_after] = 1.;
      //+ 2*pth->YHe/(_not4_*(1.-pth->YHe));    /* xe_after_reio: H + fully ionized He */
    }

    preio->reionization_parameters[preio->index_re_reio_exponent] = pth->reionization_exponent; /* reio_exponent */
    preio->reionization_parameters[preio->index_re_reio_width] = pth->reionization_width;    /* reio_width */
    preio->reionization_parameters[preio->index_re_helium_fullreio_fraction] = pth->YHe/(_not4_*(1.-pth->YHe)); /* helium_fullreio_fraction (checked before that denominator is non-zero) */
    preio->reionization_parameters[preio->index_re_helium_fullreio_redshift] = pth->helium_fullreio_redshift; /* helium_fullreio_redshift */
    preio->reionization_parameters[preio->index_re_helium_fullreio_width] = pth->helium_fullreio_width;    /* helium_fullreio_width */

    class_test(preio->reionization_parameters[preio->index_re_reio_exponent]==0,
               pth->error_message,
               "stop to avoid division by zero");

    class_test(preio->reionization_parameters[preio->index_re_reio_width]==0,
               pth->error_message,
               "stop to avoid division by zero");

    class_test(preio->reionization_parameters[preio->index_re_helium_fullreio_width]==0,
               pth->error_message,
               "stop to avoid division by zero");

    /** - --> if reionization redshift given as an input, initialize the remaining values*/

    if (pth->reio_z_or_tau == reio_z) {

      /* reionization redshift */
      preio->reionization_parameters[preio->index_re_reio_redshift] = pth->z_reio;

      /* infer starting redshift for hydrogen */

      if (pth->reio_parametrization == reio_camb) {

        preio->reionization_parameters[preio->index_re_reio_start] = preio->reionization_parameters[preio->index_re_reio_redshift]+
          ppr->reionization_start_factor*pth->reionization_width;

        /* if starting redshift for helium is larger, take that one (does not happen in realistic models) */
        if (preio->reionization_parameters[preio->index_re_reio_start] <
            pth->helium_fullreio_redshift+ppr->reionization_start_factor*pth->helium_fullreio_width)

          preio->reionization_parameters[preio->index_re_reio_start] =
            pth->helium_fullreio_redshift+ppr->reionization_start_factor*pth->helium_fullreio_width;

      }
      else {

        preio->reionization_parameters[preio->index_re_reio_start] = pth->z_reio;
      }

      class_test(preio->reionization_parameters[preio->index_re_reio_start] > ppr->reionization_z_start_max,
                 pth->error_message,
                 "starting redshift for reionization > reionization_z_start_max = %e\n",ppr->reionization_z_start_max);

    }

    /** - --> if reionization optical depth given as an input, find reionization redshift by bisection and initialize the remaining values */
    if (pth->reio_z_or_tau == reio_tau) {
      z_sup = ppr->reionization_z_start_max-ppr->reionization_start_factor*pth->reionization_width;
      class_test(z_sup < 0.,
                 pth->error_message,
                 "parameters are such that reionization cannot take place before today while starting after z_start_max; need to increase z_start_max");

      /* maximum possible reionization redshift */
      preio->reionization_parameters[preio->index_re_reio_redshift] = z_sup;
      /* maximum possible starting redshift */
      preio->reionization_parameters[preio->index_re_reio_start] = ppr->reionization_z_start_max;
    }
    break;

    /** - (c) if reionization implemented with reio_bins_tanh scheme */
  case reio_bins_tanh:

    /* this algorithm requires at least two bin centers (i.e. at least 4 values in the (z,xe) array, counting the edges). */
    class_test(pth->binned_reio_num<2,
               pth->error_message,
               "current implementation of binned reio requires at least two bin centers");

    /* check that this input can be interpreted by the code */
    for (bin=1; bin<pth->binned_reio_num; bin++) {
      class_test(pth->binned_reio_z[bin-1]>=pth->binned_reio_z[bin],
                 pth->error_message,
                 "value of reionization bin centers z_i expected to be passed in growing order: %e, %e",
                 pth->binned_reio_z[bin-1],
                 pth->binned_reio_z[bin]);
    }

    /* the code will not only copy here the "bin centers" passed in input. It will add an initial and final value for (z,xe).
       First, fill all entries except the first and the last */
    for (bin=1; bin<preio->re_z_size-1; bin++) {
      preio->reionization_parameters[preio->index_re_first_z+bin] = pth->binned_reio_z[bin-1];
      preio->reionization_parameters[preio->index_re_first_xe+bin] = pth->binned_reio_xe[bin-1];
    }

    /* find largest value of z in the array. We choose to define it as z_(i_max) + 2*(the distance between z_(i_max) and z_(i_max-1)). E.g. if
       the bins are in 10,12,14, the largest z will be 18. */
    preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-1] =
      preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-2]
      +2.*(preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-2]
           -preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-3]);

    /* copy this value in reio_start */
    preio->reionization_parameters[preio->index_re_reio_start] = preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-1];

    /* check it's not too big */
    class_test(preio->reionization_parameters[preio->index_re_reio_start] > ppr->reionization_z_start_max,
               pth->error_message,
               "starting redshift for reionization = %e, reionization_z_start_max = %e, you must change the binning or increase reionization_z_start_max",
               preio->reionization_parameters[preio->index_re_reio_start],
               ppr->reionization_z_start_max);

    /* find smallest value of z in the array. We choose to define it as z_0 - (the distance between z_1 and z_0). E.g. if
       the bins are in 10,12,14, the stop redshift will be 8. */
    preio->reionization_parameters[preio->index_re_first_z] =
      2.*preio->reionization_parameters[preio->index_re_first_z+1]
      -preio->reionization_parameters[preio->index_re_first_z+2];

    /* check it's not too small */
    /* 6.06.2015: changed this test to simply imposing that the first z is at least zero */
    /*
      class_test(preio->reionization_parameters[preio->index_re_first_z] < 0,
      pth->error_message,
      "final redshift for reionization = %e, you must change the binning or redefine the way in which the code extrapolates below the first value of z_i",preio->reionization_parameters[preio->index_re_first_z]);
    */
    if (preio->reionization_parameters[preio->index_re_first_z] < 0) {
      preio->reionization_parameters[preio->index_re_first_z] = 0.;
    }

    /* infer xe after reio */
    preio->reionization_parameters[preio->index_re_first_xe] = 1. + pth->YHe/(_not4_*(1.-pth->YHe)); /* xe_after_reio: H + singly ionized He (note: segmentation fault impossible,
                                                                                                        checked before that denominator is non-zero) */

    /* pass step sharpness parameter */
    preio->reionization_parameters[preio->index_re_step_sharpness] = pth->binned_reio_step_sharpness;
    break;

    /** - (d) if reionization implemented with reio_many_tanh scheme */
  case reio_many_tanh:

    /* this algorithm requires at least one jump centers */
    class_test(pth->many_tanh_num<1,
               pth->error_message,
               "current implementation of reio_many_tanh requires at least one jump center");

    /* check that z input can be interpreted by the code */
    for (bin=1; bin<pth->many_tanh_num; bin++) {
      class_test(pth->many_tanh_z[bin-1]>=pth->many_tanh_z[bin],
                 pth->error_message,
                 "value of reionization bin centers z_i expected to be passed in growing order: %e, %e",
                 pth->many_tanh_z[bin-1],
                 pth->many_tanh_z[bin]);

    }

    /* the code will not only copy here the "jump centers" passed in input. It will add an initial and final value for (z,xe).
       First, fill all entries except the first and the last */
    for (bin=1; bin<preio->re_z_size-1; bin++) {

      preio->reionization_parameters[preio->index_re_first_z+bin] = pth->many_tanh_z[bin-1];

      /* check that xe input can be interpreted by the code */
      xe_input = pth->many_tanh_xe[bin-1];
      if (xe_input >= 0.) {
        xe_actual = xe_input;
      }
      //-1 means "after hydrogen + first helium recombination"
      else if ((xe_input<-0.9) && (xe_input>-1.1)) {
        xe_actual = 1. + pth->YHe/(_not4_*(1.-pth->YHe));
      }
      //-2 means "after hydrogen + second helium recombination"
      else if ((xe_input<-1.9) && (xe_input>-2.1)) {
        xe_actual = 1. + 2.*pth->YHe/(_not4_*(1.-pth->YHe));
      }
      //other negative number is nonsense
      else {
        class_stop(pth->error_message,
                   "Your entry for many_tanh_xe[%d] is %e, this makes no sense (either positive or 0,-1,-2)",
                   bin-1,pth->many_tanh_xe[bin-1]);
      }

      preio->reionization_parameters[preio->index_re_first_xe+bin] = xe_actual;
    }

    /* find largest value of z in the array. We choose to define it as z_(i_max) + ppr->reionization_start_factor*step_sharpness. */
    preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-1] =
      preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-2]
      +ppr->reionization_start_factor*pth->many_tanh_width;

    /* copy this value in reio_start */
    preio->reionization_parameters[preio->index_re_reio_start] = preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-1];

    /* check it's not too big */
    class_test(preio->reionization_parameters[preio->index_re_reio_start] > ppr->reionization_z_start_max,
               pth->error_message,
               "starting redshift for reionization = %e, reionization_z_start_max = %e, you must change the binning or increase reionization_z_start_max",
               preio->reionization_parameters[preio->index_re_reio_start],
               ppr->reionization_z_start_max);

    /* find smallest value of z in the array. We choose to define it as z_0 - ppr->reionization_start_factor*step_sharpness, but at least zero. */
    preio->reionization_parameters[preio->index_re_first_z] =
      preio->reionization_parameters[preio->index_re_first_z+1]
      -ppr->reionization_start_factor*pth->many_tanh_width;

    if (preio->reionization_parameters[preio->index_re_first_z] < 0) {
      preio->reionization_parameters[preio->index_re_first_z] = 0.;
    }

    /* infer xe after reio */
    preio->reionization_parameters[preio->index_re_first_xe] = preio->reionization_parameters[preio->index_re_first_xe+1];

    /* if we want to model only hydrogen reionization and neglect both helium reionization */
    //preio->reionization_parameters[preio->index_re_first_xe] = 1.;

    /* if we want to model only hydrogen + first helium reionization and neglect second helium reionization */
    //preio->reionization_parameters[preio->index_re_first_xe] = 1. + pth->YHe/(_not4_*(1.-pth->YHe));

    /* if we want to model hydrogen + two helium reionization */
    //preio->reionization_parameters[preio->index_re_first_xe] = 1. + 2.*pth->YHe/(_not4_*(1.-pth->YHe));

    /* pass step sharpness parameter */
    class_test(pth->many_tanh_width<=0,
               pth->error_message,
               "many_tanh_width must be strictly positive, you passed %e",
               pth->many_tanh_width);

    preio->reionization_parameters[preio->index_re_step_sharpness] = pth->many_tanh_width;
    break;

    /** - (e) if reionization implemented with reio_inter scheme */
  case reio_inter:

    /* this parametrization requires at least one point (z,xe) */
    class_test(pth->reio_inter_num<1,
               pth->error_message,
               "current implementation of reio_inter requires at least one point (z,xe)");

    /* this parametrization requires that the first z value is zero */
    class_test(pth->reio_inter_z[0] != 0.,
               pth->error_message,
               "For reio_inter scheme, the first value of reio_inter_z[...]  should always be zero, you passed %e",
               pth->reio_inter_z[0]);

    /* check that z input can be interpreted by the code */
    for (point=1; point<pth->reio_inter_num; point++) {
      class_test(pth->reio_inter_z[point-1]>=pth->reio_inter_z[point],
                 pth->error_message,
                 "value of reionization bin centers z_i expected to be passed in growing order, unlike: %e, %e",
                 pth->reio_inter_z[point-1],
                 pth->reio_inter_z[point]);
    }

    /* this parametrization requires that the last x_i value is zero (the code will substitute it with the value that one would get in
       absence of reionization, as compute by the recombination code) */
    class_test(pth->reio_inter_xe[pth->reio_inter_num-1] != 0.,
               pth->error_message,
               "For reio_inter scheme, the last value of reio_inter_xe[...]  should always be zero, you passed %e",
               pth->reio_inter_xe[pth->reio_inter_num-1]);

    /* copy here the (z,xe) values passed in input. */
    for (point=0; point<preio->re_z_size; point++) {

      preio->reionization_parameters[preio->index_re_first_z+point] = pth->reio_inter_z[point];

      /* check that xe input can be interpreted by the code */
      xe_input = pth->reio_inter_xe[point];
      if (xe_input >= 0.) {
        xe_actual = xe_input;
      }
      //-1 means "after hydrogen + first helium recombination"
      else if ((xe_input<-0.9) && (xe_input>-1.1)) {
        xe_actual = 1. + pth->YHe/(_not4_*(1.-pth->YHe));
      }
      //-2 means "after hydrogen + second helium recombination"
      else if ((xe_input<-1.9) && (xe_input>-2.1)) {
        xe_actual = 1. + 2.*pth->YHe/(_not4_*(1.-pth->YHe));
      }
      //other negative number is nonsense
      else {
        class_stop(pth->error_message,
                   "Your entry for reio_inter_xe[%d] is %e, this makes no sense (either positive or 0,-1,-2)",
                   point,pth->reio_inter_xe[point]);
      }

      preio->reionization_parameters[preio->index_re_first_xe+point] = xe_actual;
    }

    /* copy highest redshift in reio_start */
    preio->reionization_parameters[preio->index_re_reio_start] = preio->reionization_parameters[preio->index_re_first_z+preio->re_z_size-1];

    /* check it's not too big */
    class_test(preio->reionization_parameters[preio->index_re_reio_start] > ppr->reionization_z_start_max,
               pth->error_message,
               "starting redshift for reionization = %e, reionization_z_start_max = %e, you must change the binning or increase reionization_z_start_max",
               preio->reionization_parameters[preio->index_re_reio_start],
               ppr->reionization_z_start_max);
    break;

  default:
    class_stop(pth->error_message,
               "value of reio_parametrization=%d unclear",pth->reio_parametrization);
    break;
  }

  /* infer conf_time_reio from z_reio */
  class_call(background_tau_of_z(pba,pth->z_reio,&(pth->conf_time_reio)),
             pba->error_message,
             pth->error_message);

  return _SUCCESS_;

}

// Assembly:
subq $0x16068, %rsp          # imm = 0x16068
movq %rdi, 0x16058(%rsp)
movq %rsi, 0x16050(%rsp)
movq %rdx, 0x16048(%rsp)
movq %rcx, 0x16040(%rsp)
movq 0x16040(%rsp), %rax
movslq 0x40(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, %rcx
movq 0x16040(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x16040(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xb7916
movq 0x16040(%rsp), %rax
movslq 0x40(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x1601c(%rsp)
leaq 0x15810(%rsp), %rdi
movl 0x1601c(%rsp), %ecx
leaq 0x11a73d(%rip), %rsi    # 0x1d2004
leaq 0x13ae6b(%rip), %rdx    # 0x1f2739
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x15810(%rsp), %r8
leaq 0x11a741(%rip), %rsi    # 0x1d2034
leaq 0x13ae5e(%rip), %rdx    # 0x1f2758
movl $0x4a0, %ecx            # imm = 0x4A0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16058(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x3f0(%rax), %xmm0
jb 0xb79a7
leaq 0x15010(%rsp), %rdi
leaq 0x13ae49(%rip), %rsi    # 0x1f2783
movb $0x0, %al
callq 0x5b9c0
leaq 0x14810(%rsp), %rdi
leaq 0x15010(%rsp), %rcx
leaq 0x11a72a(%rip), %rsi    # 0x1d2082
leaq 0x13ae75(%rip), %rdx    # 0x1f27d4
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x14810(%rsp), %r8
leaq 0x11a6b0(%rip), %rsi    # 0x1d2034
leaq 0x13adcd(%rip), %rdx    # 0x1f2758
movl $0x4a4, %ecx            # imm = 0x4A4
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16048(%rsp), %rax
movl 0x18(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x5, %rax
ja 0xb9585
movq 0x8(%rsp), %rax
leaq 0x139c03(%rip), %rcx    # 0x1f15d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0xb9605
movq 0x16048(%rsp), %rax
cmpl $0x1, 0x18(%rax)
jne 0xb7a62
movq 0x16048(%rsp), %rax
movsd (%rax), %xmm1
movq 0x16048(%rsp), %rax
movsd 0x11a823(%rip), %xmm2   # 0x1d2248
subsd (%rax), %xmm2
movsd 0x139aa7(%rip), %xmm0   # 0x1f14d8
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x11a807(%rip), %xmm0   # 0x1d2248
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x10(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
cmpl $0x3, 0x18(%rax)
jne 0xb7a95
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x10(%rcx), %rcx
movsd 0x11a7b8(%rip), %xmm0   # 0x1d2248
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movsd 0x48(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x4(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movsd (%rax), %xmm0
movq 0x16048(%rsp), %rax
movsd 0x11a743(%rip), %xmm2   # 0x1d2248
subsd (%rax), %xmm2
movsd 0x1399c7(%rip), %xmm1   # 0x1f14d8
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x14(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movsd 0x50(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movsd 0x58(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x1c(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb7c2e
jp 0xb7c2e
leaq 0x14010(%rsp), %rdi
leaq 0x11c163(%rip), %rsi    # 0x1d3d24
movb $0x0, %al
callq 0x5b9c0
leaq 0x13810(%rsp), %rdi
leaq 0x14010(%rsp), %rcx
leaq 0x11a4a3(%rip), %rsi    # 0x1d2082
leaq 0x13ac10(%rip), %rdx    # 0x1f27f6
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x13810(%rsp), %r8
leaq 0x11a429(%rip), %rsi    # 0x1d2034
leaq 0x13ab46(%rip), %rdx    # 0x1f2758
movl $0x4c5, %ecx            # imm = 0x4C5
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb7cd2
jp 0xb7cd2
leaq 0x13010(%rsp), %rdi
leaq 0x11c0bf(%rip), %rsi    # 0x1d3d24
movb $0x0, %al
callq 0x5b9c0
leaq 0x12810(%rsp), %rdi
leaq 0x13010(%rsp), %rcx
leaq 0x11a3ff(%rip), %rsi    # 0x1d2082
leaq 0x13abad(%rip), %rdx    # 0x1f2837
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x12810(%rsp), %r8
leaq 0x11a385(%rip), %rsi    # 0x1d2034
leaq 0x13aaa2(%rip), %rdx    # 0x1f2758
movl $0x4c9, %ecx            # imm = 0x4C9
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x1c(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb7d76
jp 0xb7d76
leaq 0x12010(%rsp), %rdi
leaq 0x11c01b(%rip), %rsi    # 0x1d3d24
movb $0x0, %al
callq 0x5b9c0
leaq 0x11810(%rsp), %rdi
leaq 0x12010(%rsp), %rcx
leaq 0x11a35b(%rip), %rsi    # 0x1d2082
leaq 0x13ab47(%rip), %rdx    # 0x1f2875
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x11810(%rsp), %r8
leaq 0x11a2e1(%rip), %rsi    # 0x1d2034
leaq 0x13a9fe(%rip), %rdx    # 0x1f2758
movl $0x4cd, %ecx            # imm = 0x4CD
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16048(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0xb7fb2
movq 0x16048(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
cmpl $0x1, 0x18(%rax)
jne 0xb7ec7
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x16058(%rsp), %rax
movsd 0x400(%rax), %xmm0
movq 0x16048(%rsp), %rax
movsd 0x40(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x16048(%rsp), %rax
movsd 0x50(%rax), %xmm2
movq 0x16058(%rsp), %rax
movsd 0x400(%rax), %xmm0
movq 0x16048(%rsp), %rax
movsd 0x58(%rax), %xmm3
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb7ec5
movq 0x16048(%rsp), %rax
movsd 0x50(%rax), %xmm1
movq 0x16058(%rsp), %rax
movsd 0x400(%rax), %xmm0
movq 0x16048(%rsp), %rax
movsd 0x58(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xb7ef1
movq 0x16048(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16058(%rsp), %rax
ucomisd 0x3e8(%rax), %xmm0
jbe 0xb7fb0
leaq 0x11010(%rsp), %rdi
movq 0x16058(%rsp), %rax
movsd 0x3e8(%rax), %xmm0
leaq 0x13a97b(%rip), %rsi    # 0x1f28be
movb $0x1, %al
callq 0x5b9c0
leaq 0x10810(%rsp), %rdi
leaq 0x11010(%rsp), %rcx
leaq 0x11a121(%rip), %rsi    # 0x1d2082
leaq 0x13a99a(%rip), %rdx    # 0x1f2902
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x10810(%rsp), %r8
leaq 0x11a0a7(%rip), %rsi    # 0x1d2034
leaq 0x13a7c4(%rip), %rdx    # 0x1f2758
movl $0x4ec, %ecx            # imm = 0x4EC
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
jmp 0xb7fb2
movq 0x16048(%rsp), %rax
cmpl $0x1, 0x1c(%rax)
jne 0xb80f5
movq 0x16058(%rsp), %rax
movsd 0x3e8(%rax), %xmm1
movq 0x16058(%rsp), %rax
movsd 0x400(%rax), %xmm0
movq 0x16048(%rsp), %rax
movsd 0x40(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x16020(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x16020(%rsp), %xmm0
jbe 0xb80a3
leaq 0x10010(%rsp), %rdi
leaq 0x13a927(%rip), %rsi    # 0x1f295d
movb $0x0, %al
callq 0x5b9c0
leaq 0xf810(%rsp), %rdi
leaq 0x10010(%rsp), %rcx
leaq 0x11a02e(%rip), %rsi    # 0x1d2082
leaq 0x13a986(%rip), %rdx    # 0x1f29e1
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xf810(%rsp), %r8
leaq 0x119fb4(%rip), %rsi    # 0x1d2034
leaq 0x13a6d1(%rip), %rdx    # 0x1f2758
movl $0x4f5, %ecx            # imm = 0x4F5
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movsd 0x16020(%rsp), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16058(%rsp), %rax
movsd 0x3e8(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xb9605
movq 0x16048(%rsp), %rax
cmpl $0x2, 0x60(%rax)
jge 0xb8184
leaq 0xf010(%rsp), %rdi
leaq 0x13a8d5(%rip), %rsi    # 0x1f29ec
movb $0x0, %al
callq 0x5b9c0
leaq 0xe810(%rsp), %rdi
leaq 0xf010(%rsp), %rcx
leaq 0x119f4d(%rip), %rsi    # 0x1d2082
leaq 0x13a8f8(%rip), %rdx    # 0x1f2a34
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xe810(%rsp), %r8
leaq 0x119ed3(%rip), %rsi    # 0x1d2034
leaq 0x13a5f0(%rip), %rdx    # 0x1f2758
movl $0x504, %ecx            # imm = 0x504
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movl $0x1, 0x1603c(%rsp)
movl 0x1603c(%rsp), %eax
movq 0x16048(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0xb82af
movq 0x16048(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16048(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0x1603c(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xb8297
leaq 0xe010(%rsp), %rdi
movq 0x16048(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16048(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0x1603c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
leaq 0x13a821(%rip), %rsi    # 0x1f2a4b
movb $0x2, %al
callq 0x5b9c0
leaq 0xd810(%rsp), %rdi
leaq 0xe010(%rsp), %rcx
leaq 0x119e3a(%rip), %rsi    # 0x1d2082
leaq 0x13a851(%rip), %rdx    # 0x1f2aa0
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xd810(%rsp), %r8
leaq 0x119dc0(%rip), %rsi    # 0x1d2034
leaq 0x13a4dd(%rip), %rdx    # 0x1f2758
movl $0x50c, %ecx            # imm = 0x50C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
jmp 0xb8299
movl 0x1603c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1603c(%rsp)
jmp 0xb818f
movl $0x1, 0x1603c(%rsp)
movl 0x1603c(%rsp), %eax
movq 0x16040(%rsp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xb8375
movq 0x16048(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
addl 0x1603c(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movq 0x70(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x28(%rcx), %ecx
addl 0x1603c(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1603c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1603c(%rsp)
jmp 0xb82ba
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16058(%rsp), %rax
ucomisd 0x3e8(%rax), %xmm0
jbe 0xb8557
leaq 0xd010(%rsp), %rdi
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16058(%rsp), %rax
movsd 0x3e8(%rax), %xmm1
leaq 0x13a5e9(%rip), %rsi    # 0x1f2ad3
movb $0x2, %al
callq 0x5b9c0
leaq 0xc810(%rsp), %rdi
leaq 0xd010(%rsp), %rcx
leaq 0x119b7a(%rip), %rsi    # 0x1d2082
leaq 0x13a3f3(%rip), %rdx    # 0x1f2902
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xc810(%rsp), %r8
leaq 0x119b00(%rip), %rsi    # 0x1d2034
leaq 0x13a21d(%rip), %rdx    # 0x1f2758
movl $0x525, %ecx            # imm = 0x525
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x24(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xb8619
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movsd (%rax), %xmm1
movq 0x16048(%rsp), %rax
movsd 0x119c13(%rip), %xmm2   # 0x1d2248
subsd (%rax), %xmm2
movsd 0x138e97(%rip), %xmm0   # 0x1f14d8
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x119bf7(%rip), %xmm0   # 0x1d2248
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x28(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movsd 0x78(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x2c(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xb9605
movq 0x16048(%rsp), %rax
cmpl $0x1, 0x80(%rax)
jge 0xb872e
leaq 0xc010(%rsp), %rdi
leaq 0x13a49b(%rip), %rsi    # 0x1f2b5c
movb $0x0, %al
callq 0x5b9c0
leaq 0xb810(%rsp), %rdi
leaq 0xc010(%rsp), %rcx
leaq 0x1199a3(%rip), %rsi    # 0x1d2082
leaq 0x13a4c1(%rip), %rdx    # 0x1f2ba7
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xb810(%rsp), %r8
leaq 0x119929(%rip), %rsi    # 0x1d2034
leaq 0x13a046(%rip), %rdx    # 0x1f2758
movl $0x546, %ecx            # imm = 0x546
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movl $0x1, 0x1603c(%rsp)
movl 0x1603c(%rsp), %eax
movq 0x16048(%rsp), %rcx
cmpl 0x80(%rcx), %eax
jge 0xb8868
movq 0x16048(%rsp), %rax
movq 0x88(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16048(%rsp), %rax
movq 0x88(%rax), %rax
movslq 0x1603c(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xb8850
leaq 0xb010(%rsp), %rdi
movq 0x16048(%rsp), %rax
movq 0x88(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16048(%rsp), %rax
movq 0x88(%rax), %rax
movslq 0x1603c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
leaq 0x13a268(%rip), %rsi    # 0x1f2a4b
movb $0x2, %al
callq 0x5b9c0
leaq 0xa810(%rsp), %rdi
leaq 0xb010(%rsp), %rcx
leaq 0x119881(%rip), %rsi    # 0x1d2082
leaq 0x13a3b4(%rip), %rdx    # 0x1f2bbc
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0xa810(%rsp), %r8
leaq 0x119807(%rip), %rsi    # 0x1d2034
leaq 0x139f24(%rip), %rdx    # 0x1f2758
movl $0x54e, %ecx            # imm = 0x54E
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
jmp 0xb8852
movl 0x1603c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1603c(%rsp)
jmp 0xb8739
movl $0x1, 0x1603c(%rsp)
movl 0x1603c(%rsp), %eax
movq 0x16040(%rsp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xb8b03
movq 0x16048(%rsp), %rax
movq 0x88(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
addl 0x1603c(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movq 0x90(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x16030(%rsp)
movsd 0x16030(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xb892a
movsd 0x16030(%rsp), %xmm0
movsd %xmm0, 0x16028(%rsp)
jmp 0xb8abe
movsd 0x119a06(%rip), %xmm0   # 0x1d2338
ucomisd 0x16030(%rsp), %xmm0
jbe 0xb899e
movsd 0x16030(%rsp), %xmm0
movsd 0x138bf2(%rip), %xmm1   # 0x1f1540
ucomisd %xmm1, %xmm0
jbe 0xb899e
movq 0x16048(%rsp), %rax
movsd (%rax), %xmm1
movq 0x16048(%rsp), %rax
movsd 0x1198d8(%rip), %xmm2   # 0x1d2248
subsd (%rax), %xmm2
movsd 0x138b5c(%rip), %xmm0   # 0x1f14d8
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x1198bc(%rip), %xmm0   # 0x1d2248
addsd %xmm1, %xmm0
movsd %xmm0, 0x16028(%rsp)
jmp 0xb8abc
movsd 0x138ba2(%rip), %xmm0   # 0x1f1548
ucomisd 0x16030(%rsp), %xmm0
jbe 0xb8a1a
movsd 0x16030(%rsp), %xmm0
movsd 0x138b8e(%rip), %xmm1   # 0x1f1550
ucomisd %xmm1, %xmm0
jbe 0xb8a1a
movq 0x16048(%rsp), %rax
movsd 0x11a2a8(%rip), %xmm1   # 0x1d2c80
mulsd (%rax), %xmm1
movq 0x16048(%rsp), %rax
movsd 0x11985c(%rip), %xmm2   # 0x1d2248
subsd (%rax), %xmm2
movsd 0x138ae0(%rip), %xmm0   # 0x1f14d8
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x119840(%rip), %xmm0   # 0x1d2248
addsd %xmm1, %xmm0
movsd %xmm0, 0x16028(%rsp)
jmp 0xb8aba
leaq 0xa010(%rsp), %rdi
movl 0x1603c(%rsp), %edx
subl $0x1, %edx
movq 0x16048(%rsp), %rax
movq 0x90(%rax), %rax
movl 0x1603c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x13a197(%rip), %rsi    # 0x1f2beb
movb $0x1, %al
callq 0x5b9c0
leaq 0x9810(%rsp), %rdi
leaq 0xa010(%rsp), %rdx
leaq 0x119afb(%rip), %rsi    # 0x1d256d
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x9810(%rsp), %r8
leaq 0x11959d(%rip), %rsi    # 0x1d2034
leaq 0x139cba(%rip), %rdx    # 0x1f2758
movl $0x569, %ecx            # imm = 0x569
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
jmp 0xb8abc
jmp 0xb8abe
movsd 0x16028(%rsp), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x28(%rcx), %ecx
addl 0x1603c(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1603c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1603c(%rsp)
jmp 0xb8873
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x16058(%rsp), %rax
movsd 0x400(%rax), %xmm0
movq 0x16048(%rsp), %rax
movsd 0x98(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16058(%rsp), %rax
ucomisd 0x3e8(%rax), %xmm0
jbe 0xb8cab
leaq 0x9010(%rsp), %rdi
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16058(%rsp), %rax
movsd 0x3e8(%rax), %xmm1
leaq 0x139e95(%rip), %rsi    # 0x1f2ad3
movb $0x2, %al
callq 0x5b9c0
leaq 0x8810(%rsp), %rdi
leaq 0x9010(%rsp), %rcx
leaq 0x119426(%rip), %rsi    # 0x1d2082
leaq 0x139c9f(%rip), %rdx    # 0x1f2902
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x8810(%rsp), %r8
leaq 0x1193ac(%rip), %rsi    # 0x1d2034
leaq 0x139ac9(%rip), %rdx    # 0x1f2758
movl $0x57c, %ecx            # imm = 0x57C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x16058(%rsp), %rax
movsd 0x400(%rax), %xmm0
movq 0x16048(%rsp), %rax
movsd 0x98(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x24(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xb8d6b
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x28(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x28(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x98(%rax), %xmm0
jb 0xb8e4f
leaq 0x8010(%rsp), %rdi
movq 0x16048(%rsp), %rax
movsd 0x98(%rax), %xmm0
leaq 0x139e61(%rip), %rsi    # 0x1f2c43
movb $0x1, %al
callq 0x5b9c0
leaq 0x7810(%rsp), %rdi
leaq 0x8010(%rsp), %rcx
leaq 0x119282(%rip), %rsi    # 0x1d2082
leaq 0x139e75(%rip), %rdx    # 0x1f2c7c
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x7810(%rsp), %r8
leaq 0x119208(%rip), %rsi    # 0x1d2034
leaq 0x139925(%rip), %rdx    # 0x1f2758
movl $0x597, %ecx            # imm = 0x597
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16048(%rsp), %rax
movsd 0x98(%rax), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x2c(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xb9605
movq 0x16048(%rsp), %rax
cmpl $0x1, 0xa0(%rax)
jge 0xb8f0e
leaq 0x7010(%rsp), %rdi
leaq 0x139df3(%rip), %rsi    # 0x1f2c94
movb $0x0, %al
callq 0x5b9c0
leaq 0x6810(%rsp), %rdi
leaq 0x7010(%rsp), %rcx
leaq 0x1191c3(%rip), %rsi    # 0x1d2082
leaq 0x139e16(%rip), %rdx    # 0x1f2cdc
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x6810(%rsp), %r8
leaq 0x119149(%rip), %rsi    # 0x1d2034
leaq 0x139866(%rip), %rdx    # 0x1f2758
movl $0x5a2, %ecx            # imm = 0x5A2
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16048(%rsp), %rax
movq 0xa8(%rax), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb8f31
jp 0xb8f31
jmp 0xb8fc0
leaq 0x6010(%rsp), %rdi
movq 0x16048(%rsp), %rax
movq 0xa8(%rax), %rax
movsd (%rax), %xmm0
leaq 0x139d9f(%rip), %rsi    # 0x1f2cf2
movb $0x1, %al
callq 0x5b9c0
leaq 0x5810(%rsp), %rdi
leaq 0x6010(%rsp), %rcx
leaq 0x119111(%rip), %rsi    # 0x1d2082
leaq 0x139ddc(%rip), %rdx    # 0x1f2d54
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x5810(%rsp), %r8
leaq 0x119097(%rip), %rsi    # 0x1d2034
leaq 0x1397b4(%rip), %rdx    # 0x1f2758
movl $0x5a8, %ecx            # imm = 0x5A8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movl $0x1, 0x16038(%rsp)
movl 0x16038(%rsp), %eax
movq 0x16048(%rsp), %rcx
cmpl 0xa0(%rcx), %eax
jge 0xb90fa
movq 0x16048(%rsp), %rax
movq 0xa8(%rax), %rax
movl 0x16038(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16048(%rsp), %rax
movq 0xa8(%rax), %rax
movslq 0x16038(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xb90e2
leaq 0x5010(%rsp), %rdi
movq 0x16048(%rsp), %rax
movq 0xa8(%rax), %rax
movl 0x16038(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16048(%rsp), %rax
movq 0xa8(%rax), %rax
movslq 0x16038(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
leaq 0x139cfa(%rip), %rsi    # 0x1f2d6f
movb $0x2, %al
callq 0x5b9c0
leaq 0x4810(%rsp), %rdi
leaq 0x5010(%rsp), %rcx
leaq 0x118fef(%rip), %rsi    # 0x1d2082
leaq 0x139d32(%rip), %rdx    # 0x1f2dcc
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x4810(%rsp), %r8
leaq 0x118f75(%rip), %rsi    # 0x1d2034
leaq 0x139692(%rip), %rdx    # 0x1f2758
movl $0x5b0, %ecx            # imm = 0x5B0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
jmp 0xb90e4
movl 0x16038(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x16038(%rsp)
jmp 0xb8fcb
movq 0x16048(%rsp), %rax
movq 0xb0(%rax), %rax
movq 0x16048(%rsp), %rcx
movl 0xa0(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb9132
jp 0xb9132
jmp 0xb91d6
leaq 0x4010(%rsp), %rdi
movq 0x16048(%rsp), %rax
movq 0xb0(%rax), %rax
movq 0x16048(%rsp), %rcx
movl 0xa0(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x139c98(%rip), %rsi    # 0x1f2e01
movb $0x1, %al
callq 0x5b9c0
leaq 0x3810(%rsp), %rdi
leaq 0x4010(%rsp), %rcx
leaq 0x118efb(%rip), %rsi    # 0x1d2082
leaq 0x139cd5(%rip), %rdx    # 0x1f2e63
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x3810(%rsp), %r8
leaq 0x118e81(%rip), %rsi    # 0x1d2034
leaq 0x13959e(%rip), %rdx    # 0x1f2758
movl $0x5b8, %ecx            # imm = 0x5B8
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movl $0x0, 0x16038(%rsp)
movl 0x16038(%rsp), %eax
movq 0x16040(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xb945a
movq 0x16048(%rsp), %rax
movq 0xa8(%rax), %rax
movslq 0x16038(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
addl 0x16038(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16048(%rsp), %rax
movq 0xb0(%rax), %rax
movslq 0x16038(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x16030(%rsp)
movsd 0x16030(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xb9289
movsd 0x16030(%rsp), %xmm0
movsd %xmm0, 0x16028(%rsp)
jmp 0xb9415
movsd 0x1190a7(%rip), %xmm0   # 0x1d2338
ucomisd 0x16030(%rsp), %xmm0
jbe 0xb92fd
movsd 0x16030(%rsp), %xmm0
movsd 0x138293(%rip), %xmm1   # 0x1f1540
ucomisd %xmm1, %xmm0
jbe 0xb92fd
movq 0x16048(%rsp), %rax
movsd (%rax), %xmm1
movq 0x16048(%rsp), %rax
movsd 0x118f79(%rip), %xmm2   # 0x1d2248
subsd (%rax), %xmm2
movsd 0x1381fd(%rip), %xmm0   # 0x1f14d8
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x118f5d(%rip), %xmm0   # 0x1d2248
addsd %xmm1, %xmm0
movsd %xmm0, 0x16028(%rsp)
jmp 0xb9413
movsd 0x138243(%rip), %xmm0   # 0x1f1548
ucomisd 0x16030(%rsp), %xmm0
jbe 0xb9379
movsd 0x16030(%rsp), %xmm0
movsd 0x13822f(%rip), %xmm1   # 0x1f1550
ucomisd %xmm1, %xmm0
jbe 0xb9379
movq 0x16048(%rsp), %rax
movsd 0x119949(%rip), %xmm1   # 0x1d2c80
mulsd (%rax), %xmm1
movq 0x16048(%rsp), %rax
movsd 0x118efd(%rip), %xmm2   # 0x1d2248
subsd (%rax), %xmm2
movsd 0x138181(%rip), %xmm0   # 0x1f14d8
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x118ee1(%rip), %xmm0   # 0x1d2248
addsd %xmm1, %xmm0
movsd %xmm0, 0x16028(%rsp)
jmp 0xb9411
leaq 0x3010(%rsp), %rdi
movl 0x16038(%rsp), %edx
movq 0x16048(%rsp), %rax
movq 0xb0(%rax), %rax
movslq 0x16038(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x139ae8(%rip), %rsi    # 0x1f2e93
movb $0x1, %al
callq 0x5b9c0
leaq 0x2810(%rsp), %rdi
leaq 0x3010(%rsp), %rdx
leaq 0x1191a4(%rip), %rsi    # 0x1d256d
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x2810(%rsp), %r8
leaq 0x118c46(%rip), %rsi    # 0x1d2034
leaq 0x139363(%rip), %rdx    # 0x1f2758
movl $0x5d0, %ecx            # imm = 0x5D0
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
jmp 0xb9413
jmp 0xb9415
movsd 0x16028(%rsp), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x28(%rcx), %ecx
addl 0x16038(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x16038(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x16038(%rsp)
jmp 0xb91e1
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq 0x16040(%rsp), %rdx
addl 0x20(%rdx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16058(%rsp), %rax
ucomisd 0x3e8(%rax), %xmm0
jbe 0xb9580
leaq 0x2010(%rsp), %rdi
movq 0x16040(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x16040(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x16058(%rsp), %rax
movsd 0x3e8(%rax), %xmm1
leaq 0x1395c0(%rip), %rsi    # 0x1f2ad3
movb $0x2, %al
callq 0x5b9c0
leaq 0x1810(%rsp), %rdi
leaq 0x2010(%rsp), %rcx
leaq 0x118b51(%rip), %rsi    # 0x1d2082
leaq 0x1393ca(%rip), %rdx    # 0x1f2902
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x1810(%rsp), %r8
leaq 0x118ad7(%rip), %rsi    # 0x1d2034
leaq 0x1391f4(%rip), %rdx    # 0x1f2758
movl $0x5de, %ecx            # imm = 0x5DE
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
jmp 0xb9605
leaq 0x1010(%rsp), %rdi
movq 0x16048(%rsp), %rax
movl 0x18(%rax), %edx
leaq 0x1390a3(%rip), %rsi    # 0x1f2642
movb $0x0, %al
callq 0x5b9c0
leaq 0x810(%rsp), %rdi
leaq 0x1010(%rsp), %rdx
leaq 0x118fb0(%rip), %rsi    # 0x1d256d
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x810(%rsp), %r8
leaq 0x118a52(%rip), %rsi    # 0x1d2034
leaq 0x13916f(%rip), %rdx    # 0x1f2758
movl $0x5e3, %ecx            # imm = 0x5E3
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movq 0x16050(%rsp), %rdi
movq 0x16048(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x16048(%rsp), %rsi
addq $0xfc0, %rsi            # imm = 0xFC0
callq 0x9ee00
cmpl $0x1, %eax
jne 0xb9697
leaq 0x10(%rsp), %rdi
movq 0x16050(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x118d8a(%rip), %rsi    # 0x1d23d8
leaq 0x139897(%rip), %rdx    # 0x1f2eec
movb $0x0, %al
callq 0x5b9c0
movq 0x16048(%rsp), %rdi
addq $0x1064, %rdi           # imm = 0x1064
leaq 0x10(%rsp), %r8
leaq 0x1189bd(%rip), %rsi    # 0x1d2034
leaq 0x1390da(%rip), %rdx    # 0x1f2758
movl $0x5ea, %ecx            # imm = 0x5EA
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x16064(%rsp)
jmp 0xb96a2
movl $0x0, 0x16064(%rsp)
movl 0x16064(%rsp), %eax
addq $0x16068, %rsp          # imm = 0x16068
retq
nopw %cs:(%rax,%rax)