// File: /workspace/github_c_makefile_star2_O0/lesgourg[P]class_public/build/../source/input.c
// Function: input_shooting
int input_shooting(struct file_content * pfc,
                   struct precision * ppr,
                   struct background *pba,
                   struct thermodynamics *pth,
                   struct perturbations *ppt,
                   struct transfer *ptr,
                   struct primordial *ppm,
                   struct harmonic *phr,
                   struct fourier * pfo,
                   struct lensing *ple,
                   struct distortions *psd,
                   struct output *pop,
                   int input_verbose,
                   int * has_shooting,
                   ErrorMsg errmsg){

  /** Summary: */

  /** Define local variables */
  int flag1, flag2;
  double param1, param2;
  double * unknown_parameter;
  int unknown_parameters_size;
  int counter, index_target;
  int fevals=0;
  double xzero;
  double *dxdF, *x_inout;
  int target_indices[_NUM_TARGETS_];
  int needs_shooting;
  int shooting_failed=_FALSE_;

  /* array of parameters passed by the user for which we need shooting (= target parameters) */
  char * const target_namestrings[] = {"100*theta_s",
                                       "theta_s_100",
                                       "Neff",
                                       "Omega_dcdmdr",
                                       "omega_dcdmdr",
                                       "Omega_scf",
                                       "Omega_ini_dcdm",
                                       "omega_ini_dcdm"};

  /* array of corresponding parameters that must be adjusted in order to meet the target (= unknown parameters) */
  char * const unknown_namestrings[] = {"h",                        /* unknown param for target '100*theta_s' */
                                        "h",                        /* unknown param for target 'theta_s_100' */
                                        "N_ur",                     /* unknown param for target 'Neff' */
                                        "Omega_ini_dcdm",           /* unknown param for target 'Omega_dcdmd' */
                                        "omega_ini_dcdm",           /* unknown param for target 'omega_dcdmdr' */
                                        "scf_shooting_parameter",   /* unknown param for target 'Omega_scf' */
                                        "Omega_dcdmdr",             /* unknown param for target 'Omega_ini_dcdm' */
                                        "omega_dcdmdr"};             /* unknown param for target 'omega_ini_dcdm' */

  /* for each target, module up to which we need to run CLASS in order
     to compute the targetted quantities (not running the whole code
     each time to saves a lot of time) */
  enum computation_stage target_cs[] = {cs_thermodynamics, /* computation stage for target '100*theta_s' */
                                        cs_thermodynamics, /* computation stage for target 'theta_s_100' */
                                        cs_background,     /* computation stage for target 'Neff' */
                                        cs_background,     /* computation stage for target 'Omega_dcdmdr' */
                                        cs_background,     /* computation stage for target 'omega_dcdmdr' */
                                        cs_background,     /* computation stage for target 'Omega_scf' */
                                        cs_background,     /* computation stage for target 'Omega_ini_dcdm' */
                                        cs_background};     /* computation stage for target 'omega_ini_dcdm' */

  struct fzerofun_workspace fzw;

  *has_shooting=_FALSE_;

  /** Do we need to fix unknown parameters? */
  unknown_parameters_size = 0;
  fzw.required_computation_stage = 0;
  for (index_target = 0; index_target < _NUM_TARGETS_; index_target++){
    class_call(parser_read_double(pfc,target_namestrings[index_target],&param1,&flag1,errmsg),
               errmsg,
               errmsg);
    if (flag1 == _TRUE_){
      /* input_needs_shoting_for_target takes care of the case where, for
         instance, Omega_dcdmdr is set to 0.0, and we don't need shooting */
      class_call(input_needs_shooting_for_target(pfc,
                                                 index_target,
                                                 param1,
                                                 &needs_shooting,
                                                 errmsg),
                 errmsg,
                 errmsg);

      if (needs_shooting == _TRUE_){
        target_indices[unknown_parameters_size] = index_target;
        fzw.required_computation_stage = MAX(fzw.required_computation_stage,target_cs[index_target]);
        unknown_parameters_size++;
      }

    }
  }

  /** In the case of unknown parameters, start shooting... */
  if (unknown_parameters_size > 0) {

    /* We need to remember that we shot so we can clean up properly */
    *has_shooting=_TRUE_;

    /* Create file content structure with additional entries */
    class_call(parser_extend(pfc, unknown_parameters_size, errmsg),
               errmsg,errmsg);

    class_call(parser_init_from_pfc(pfc, &(fzw.fc), errmsg),
               errmsg,errmsg);

    class_alloc(unknown_parameter,
                unknown_parameters_size*sizeof(double),
                errmsg);
    class_alloc(fzw.unknown_parameters_index,
                unknown_parameters_size*sizeof(int),
                errmsg);

    fzw.target_size = unknown_parameters_size;
    class_alloc(fzw.target_name,
                fzw.target_size*sizeof(enum target_names),
                errmsg);
    class_alloc(fzw.target_value,
                fzw.target_size*sizeof(double),
                errmsg);

    /** Go through all cases with unknown parameters */
    for (counter = 0; counter < unknown_parameters_size; counter++){
      index_target = target_indices[counter];
      class_call(parser_read_double(pfc,
                                    target_namestrings[index_target],
                                    &param1,
                                    &flag1,
                                    errmsg),
                 errmsg,
                 errmsg);

      /* store name of target parameter */
      fzw.target_name[counter] = index_target;
      /* store target value of target parameter */
      fzw.target_value[counter] = param1;
      fzw.unknown_parameters_index[counter]=pfc->size+counter-unknown_parameters_size;
      /* substitute the name of the target parameter with the name of the
         corresponding unknown parameter */
      strcpy(fzw.fc.name[fzw.unknown_parameters_index[counter]],unknown_namestrings[index_target]);
    }

    /** If there is only one parameter, we use a more efficient Newton method for 1D cases */
    if (unknown_parameters_size == 1){

      /* We can do 1 dimensional root finding */
      if (input_verbose > 0) {
        printf("Computing unknown input parameter '%s' using input parameter '%s'\n",
               fzw.fc.name[fzw.unknown_parameters_index[0]],
               target_namestrings[fzw.target_name[0]]);
      }

      /* If shooting fails, postpone error to background module to play nice with MontePython. */
      class_call_try(input_find_root(&xzero,
                                     &fevals,
                                     ppr->tol_shooting_deltax_rel,
                                     &fzw,
                                     errmsg),
                     errmsg,
                     pba->shooting_error,
                     shooting_failed=_TRUE_);

      /* Store xzero */
      // This needs to be done with enough accuracy. A standard double has a relative
      // precision of around 1e-16, so 1e-20 should be good enough for the shooting
      class_sprintf(fzw.fc.value[fzw.unknown_parameters_index[0]],"%.20e",xzero);
      if (input_verbose > 0) {
        if (shooting_failed == _FALSE_){
          printf(" -> found '%s = %s'\n",
                  fzw.fc.name[fzw.unknown_parameters_index[0]],
                  fzw.fc.value[fzw.unknown_parameters_index[0]]);
        }
        else{
          printf("Shooting failed! Aborting...\n");
        }
      }

    }
    /** Otherwise we do multidimensional shooting */
    else{

      /* We need to do multidimensional root finding */
      if (input_verbose > 0) {
        printf("Computing unknown input parameters\n");
      }

      /* Allocate local variables */
      class_alloc(x_inout,
                  sizeof(double)*unknown_parameters_size,
                  errmsg);
      class_alloc(dxdF,
                  sizeof(double)*unknown_parameters_size,
                  errmsg);

      /* Get the guess for the initial variables */
      class_call(input_get_guess(x_inout, dxdF, &fzw, errmsg),
                 errmsg,
                 errmsg);

      /* Use multi-dimensional Newton method */
      class_call_try(fzero_Newton(input_try_unknown_parameters,
                                  x_inout,
                                  dxdF,
                                  unknown_parameters_size,
                                  ppr->tol_shooting_deltax,
                                  ppr->tol_shooting_deltaF,
                                  &fzw,
                                  &fevals,
                                  errmsg),
                     errmsg,
                     pba->shooting_error,
                     shooting_failed=_TRUE_);

      /* Store xzero */
      // This needs to be done with enough accuracy. A standard double has a relative
      // precision of around 1e-16, so 1e-20 should be good enough for the shooting
      for (counter = 0; counter < unknown_parameters_size; counter++){
        class_sprintf(fzw.fc.value[fzw.unknown_parameters_index[counter]],
                "%.20e",x_inout[counter]);
        if (input_verbose > 0) {
          if (shooting_failed == _FALSE_){
            printf(" -> found '%s = %s'\n",
                    fzw.fc.name[fzw.unknown_parameters_index[counter]],
                    fzw.fc.value[fzw.unknown_parameters_index[counter]]);
          }
          else{
            printf("Shooting failed! Aborting...\n");
          }
        }
      }

      /* Free local variables */
      free(x_inout);
      free(dxdF);
    }

    if (input_verbose > 1 && shooting_failed == _FALSE_) {
      printf("Shooting completed using %d function evaluations\n",fevals);
    }

    /** Set status of shooting */
    pba->shooting_failed = shooting_failed;

    parser_copy(&(fzw.fc), pfc, pfc->size - unknown_parameters_size, pfc->size);

    /** Free arrays allocated */
    class_call(parser_free(&(fzw.fc)),
               errmsg, errmsg);
    free(unknown_parameter);
    free(fzw.unknown_parameters_index);
    free(fzw.target_name);
    free(fzw.target_value);
  }


  /** After the 'normal' shooting is done, do special shooting just for sigma8 if needed*/
  class_call(parser_read_double(pfc,"sigma8",&param1,&flag1,errmsg),
             errmsg,
             errmsg);
  class_call(parser_read_double(pfc,"S8",&param2,&flag2,errmsg),
             errmsg,
             errmsg);
  class_test((flag1 == _TRUE_) && (flag2 == _TRUE_),
             errmsg,
             "You can only enter one of 'sigma8' or 'S8'.");
  if (flag1 == _TRUE_ || flag2 == _TRUE_) {
    /* Tell the main function that shooting indeed has occured */
    *has_shooting=_TRUE_;

    /* Create file content structure with additional entries */
    class_call(parser_extend(pfc, 1, errmsg),
               errmsg,errmsg);

    class_call(parser_init_from_pfc(pfc, &(fzw.fc), errmsg),
               errmsg,errmsg);

    fzw.target_size = 1;
    class_alloc(fzw.unknown_parameters_index,
                1*sizeof(int),
                errmsg);
    class_alloc(fzw.target_name,
                1*sizeof(enum target_names),
                errmsg);
    class_alloc(fzw.target_value,
                1*sizeof(double),
                errmsg);

    /* store name of target parameter */
    if (flag1 == _TRUE_) {
      fzw.target_name[0] = sigma8;
      fzw.target_value[0] = param1;
    }
    else if (flag2 == _TRUE_) {
      fzw.target_name[0] = S8;
      fzw.target_value[0] = param2;
    }
    /* store target value of target parameter */
    fzw.unknown_parameters_index[0]=pfc->size - 1;
    fzw.required_computation_stage = cs_nonlinear;
    /* substitute the name of the target parameter with the name of the
       corresponding unknown parameter */
    strcpy(fzw.fc.name[pfc->size - 1],"A_s");

    /* Print to the user */
    if (input_verbose > 0) {
      printf("Computing unknown input parameter '%s' using input parameter '%s'\n",
             (flag1 ==_TRUE_?"sigma8":"S8"),
             "A_s");
    }

    /* Set a guess for A_s from LCDM (doesn't need to be super accurate) */
    double A_s;
    if (flag1 == _TRUE_) {
      A_s = param1 * 2.43e-9/0.87659;
    }
    else if (flag2 == _TRUE_) {
      A_s = param2 *2.43e-9/0.891;
    }
    double sigma8_or_S8;

    /* Now run for a single time, get the value of sigma8 (or S8) for the guess*/
    class_call(input_try_unknown_parameters(&A_s,
                                            1,
                                            &fzw,
                                            &sigma8_or_S8,
                                            errmsg),
               errmsg,
               errmsg);

    A_s = (fzw.target_value[0]/sigma8_or_S8) *(fzw.target_value[0]/sigma8_or_S8) * A_s; //(truesigma/sigma_for_guess)^2 *A_s_for_guess

    /* Store the derived value with high enough accuracy */
    class_sprintf(fzw.fc.value[pfc->size - 1],"%.20e",A_s);
    if (input_verbose > 0) {
      printf(" -> found '%s = %s'\n",
             fzw.fc.name[pfc->size - 1],
             fzw.fc.value[pfc->size - 1]);
    }

    parser_copy(&(fzw.fc), pfc, pfc->size - 1, pfc->size);

    /** Free arrays allocated */
    class_call(parser_free(&(fzw.fc)),
               errmsg, errmsg);
    free(fzw.unknown_parameters_index);
    free(fzw.target_name);
    free(fzw.target_value);
  }

  return _SUCCESS_;

}

// Assembly:
subq $0xd278, %rsp           # imm = 0xD278
movq 0xd2c0(%rsp), %rax
movq 0xd2b8(%rsp), %rax
movl 0xd2b0(%rsp), %eax
movq 0xd2a8(%rsp), %rax
movq 0xd2a0(%rsp), %rax
movq 0xd298(%rsp), %rax
movq 0xd290(%rsp), %rax
movq 0xd288(%rsp), %rax
movq 0xd280(%rsp), %rax
movq %rdi, 0xd268(%rsp)
movq %rsi, 0xd260(%rsp)
movq %rdx, 0xd258(%rsp)
movq %rcx, 0xd250(%rsp)
movq %r8, 0xd248(%rsp)
movq %r9, 0xd240(%rsp)
movl $0x0, 0xd210(%rsp)
movl $0x0, 0xd1c8(%rsp)
leaq 0xd180(%rsp), %rdi
leaq 0x1ba86d(%rip), %rsi    # 0x2236b0
movl $0x40, %edx
callq 0x8300
leaq 0xd140(%rsp), %rdi
leaq 0x1ba894(%rip), %rsi    # 0x2236f0
movl $0x40, %edx
callq 0x8300
movq 0x167283(%rip), %rax    # 0x1d00f0
movq %rax, 0xd120(%rsp)
movq 0x16727c(%rip), %rax    # 0x1d00f8
movq %rax, 0xd128(%rsp)
movq 0x167275(%rip), %rax    # 0x1d0100
movq %rax, 0xd130(%rsp)
movq 0x16726e(%rip), %rax    # 0x1d0108
movq %rax, 0xd138(%rsp)
movq 0xd2b8(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0xd21c(%rsp)
movl $0x0, 0xd11c(%rsp)
movl $0x0, 0xd214(%rsp)
cmpl $0x8, 0xd214(%rsp)
jge 0x690a5
movq 0xd268(%rsp), %rdi
movslq 0xd214(%rsp), %rax
movq 0xd180(%rsp,%rax,8), %rsi
movq 0xd2c0(%rsp), %r8
leaq 0xd230(%rsp), %rdx
leaq 0xd23c(%rsp), %rcx
callq 0x385d0
cmpl $0x1, %eax
jne 0x68f78
leaq 0xc8d0(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14e4a8(%rip), %rsi    # 0x1b73d8
leaq 0x1530c1(%rip), %rdx    # 0x1bbff8
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0xc8d0(%rsp), %r8
leaq 0x14e0df(%rip), %rsi    # 0x1b7034
leaq 0x1530eb(%rip), %rdx    # 0x1bc047
movl $0x23c, %ecx            # imm = 0x23C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
cmpl $0x1, 0xd23c(%rsp)
jne 0x6908d
movq 0xd268(%rsp), %rdi
movl 0xd214(%rsp), %esi
movsd 0xd230(%rsp), %xmm0
movq 0xd2c0(%rsp), %rcx
leaq 0xd1cc(%rsp), %rdx
callq 0x6c7d0
cmpl $0x1, %eax
jne 0x69017
leaq 0xc0d0(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14e409(%rip), %rsi    # 0x1b73d8
leaq 0x153080(%rip), %rdx    # 0x1bc056
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0xc0d0(%rsp), %r8
leaq 0x14e040(%rip), %rsi    # 0x1b7034
leaq 0x15304c(%rip), %rdx    # 0x1bc047
movl $0x246, %ecx            # imm = 0x246
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
cmpl $0x1, 0xd1cc(%rsp)
jne 0x6908b
movl 0xd214(%rsp), %ecx
movslq 0xd21c(%rsp), %rax
movl %ecx, 0xd1d0(%rsp,%rax,4)
movl 0xd11c(%rsp), %eax
movslq 0xd214(%rsp), %rcx
cmpl 0xd120(%rsp,%rcx,4), %eax
jae 0x69064
movslq 0xd214(%rsp), %rax
movl 0xd120(%rsp,%rax,4), %eax
movl %eax, 0xc(%rsp)
jmp 0x6906f
movl 0xd11c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0xd11c(%rsp)
movl 0xd21c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd21c(%rsp)
jmp 0x6908d
jmp 0x6908f
movl 0xd214(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd214(%rsp)
jmp 0x68ed1
cmpl $0x0, 0xd21c(%rsp)
jle 0x69c60
movq 0xd2b8(%rsp), %rax
movl $0x1, (%rax)
movq 0xd268(%rsp), %rdi
movl 0xd21c(%rsp), %esi
movq 0xd2c0(%rsp), %rdx
callq 0x3a9b0
cmpl $0x1, %eax
jne 0x69141
leaq 0xb8d0(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14e2df(%rip), %rsi    # 0x1b73d8
leaq 0x152faa(%rip), %rdx    # 0x1bc0aa
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0xb8d0(%rsp), %r8
leaq 0x14df16(%rip), %rsi    # 0x1b7034
leaq 0x152f22(%rip), %rdx    # 0x1bc047
movl $0x259, %ecx            # imm = 0x259
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd268(%rsp), %rdi
leaq 0xd0d8(%rsp), %rsi
addq $0x8, %rsi
movq 0xd2c0(%rsp), %rdx
callq 0x3ad70
cmpl $0x1, %eax
jne 0x691c6
leaq 0xb0d0(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14e25a(%rip), %rsi    # 0x1b73d8
leaq 0x152f59(%rip), %rdx    # 0x1bc0de
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0xb0d0(%rsp), %r8
leaq 0x14de91(%rip), %rsi    # 0x1b7034
leaq 0x152e9d(%rip), %rdx    # 0x1bc047
movl $0x25c, %ecx            # imm = 0x25C
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movslq 0xd21c(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xd220(%rsp)
cmpq $0x0, 0xd220(%rsp)
jne 0x6925b
movslq 0xd21c(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0xb0cc(%rsp)
leaq 0xa8c0(%rsp), %rdi
movl 0xb0cc(%rsp), %ecx
leaq 0x14ddf1(%rip), %rsi    # 0x1b7004
leaq 0x152ef1(%rip), %rdx    # 0x1bc10b
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0xa8c0(%rsp), %r8
leaq 0x14ddfc(%rip), %rsi    # 0x1b7034
leaq 0x152e08(%rip), %rdx    # 0x1bc047
movl $0x260, %ecx            # imm = 0x260
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movslq 0xd21c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x8460
movq %rax, 0xd0d8(%rsp)
cmpq $0x0, 0xd0d8(%rsp)
jne 0x692f0
movslq 0xd21c(%rsp), %rax
shlq $0x2, %rax
movl %eax, 0xa8bc(%rsp)
leaq 0xa0b0(%rsp), %rdi
movl 0xa8bc(%rsp), %ecx
leaq 0x14dd5c(%rip), %rsi    # 0x1b7004
leaq 0x152e6e(%rip), %rdx    # 0x1bc11d
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0xa0b0(%rsp), %r8
leaq 0x14dd67(%rip), %rsi    # 0x1b7034
leaq 0x152d73(%rip), %rdx    # 0x1bc047
movl $0x263, %ecx            # imm = 0x263
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movl 0xd21c(%rsp), %eax
movl %eax, 0xd118(%rsp)
movslq 0xd118(%rsp), %rdi
shlq $0x2, %rdi
callq 0x8460
movq %rax, 0xd108(%rsp)
cmpq $0x0, 0xd108(%rsp)
jne 0x69393
movslq 0xd118(%rsp), %rax
shlq $0x2, %rax
movl %eax, 0xa0ac(%rsp)
leaq 0x98a0(%rsp), %rdi
movl 0xa0ac(%rsp), %ecx
leaq 0x14dcb9(%rip), %rsi    # 0x1b7004
leaq 0x152de8(%rip), %rdx    # 0x1bc13a
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x98a0(%rsp), %r8
leaq 0x14dcc4(%rip), %rsi    # 0x1b7034
leaq 0x152cd0(%rip), %rdx    # 0x1bc047
movl $0x268, %ecx            # imm = 0x268
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movslq 0xd118(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xd110(%rsp)
cmpq $0x0, 0xd110(%rsp)
jne 0x69428
movslq 0xd118(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x989c(%rsp)
leaq 0x9090(%rsp), %rdi
movl 0x989c(%rsp), %ecx
leaq 0x14dc24(%rip), %rsi    # 0x1b7004
leaq 0x152d63(%rip), %rdx    # 0x1bc14a
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x9090(%rsp), %r8
leaq 0x14dc2f(%rip), %rsi    # 0x1b7034
leaq 0x152c3b(%rip), %rdx    # 0x1bc047
movl $0x26b, %ecx            # imm = 0x26B
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movl $0x0, 0xd218(%rsp)
movl 0xd218(%rsp), %eax
cmpl 0xd21c(%rsp), %eax
jge 0x695a8
movslq 0xd218(%rsp), %rax
movl 0xd1d0(%rsp,%rax,4), %eax
movl %eax, 0xd214(%rsp)
movq 0xd268(%rsp), %rdi
movslq 0xd214(%rsp), %rax
movq 0xd180(%rsp,%rax,8), %rsi
movq 0xd2c0(%rsp), %r8
leaq 0xd230(%rsp), %rdx
leaq 0xd23c(%rsp), %rcx
callq 0x385d0
cmpl $0x1, %eax
jne 0x694f6
leaq 0x8890(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14df2a(%rip), %rsi    # 0x1b73d8
leaq 0x152ca6(%rip), %rdx    # 0x1bc15b
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x8890(%rsp), %r8
leaq 0x14db61(%rip), %rsi    # 0x1b7034
leaq 0x152b6d(%rip), %rdx    # 0x1bc047
movl $0x276, %ecx            # imm = 0x276
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movl 0xd214(%rsp), %edx
movq 0xd108(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movsd 0xd230(%rsp), %xmm0
movq 0xd110(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %edx
addl 0xd218(%rsp), %edx
subl 0xd21c(%rsp), %edx
movq 0xd0d8(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0xd0f0(%rsp), %rdi
movq 0xd0d8(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0xa, %rax
addq %rax, %rdi
movslq 0xd214(%rsp), %rax
movq 0xd140(%rsp,%rax,8), %rsi
callq 0x8370
movl 0xd218(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd218(%rsp)
jmp 0x69433
cmpl $0x1, 0xd21c(%rsp)
jne 0x69764
cmpl $0x0, 0xd2b0(%rsp)
jle 0x695fa
movq 0xd0f0(%rsp), %rsi
movq 0xd0d8(%rsp), %rax
movslq (%rax), %rax
shlq $0xa, %rax
addq %rax, %rsi
movq 0xd108(%rsp), %rax
movl (%rax), %eax
movq 0xd180(%rsp,%rax,8), %rdx
leaq 0x152bbb(%rip), %rdi    # 0x1bc1ae
movb $0x0, %al
callq 0x8030
movq 0xd260(%rsp), %rax
movsd 0x78(%rax), %xmm0
movq 0xd2c0(%rsp), %rcx
leaq 0xd208(%rsp), %rdi
leaq 0xd210(%rsp), %rsi
leaq 0xd0d8(%rsp), %rdx
callq 0x6c830
cmpl $0x1, %eax
jne 0x69692
leaq 0x8090(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14dd90(%rip), %rsi    # 0x1b73d8
leaq 0x152ba2(%rip), %rdx    # 0x1bc1f1
movb $0x0, %al
callq 0x5b9c0
movq 0xd258(%rsp), %rdi
addq $0x382, %rdi            # imm = 0x382
leaq 0x8090(%rsp), %r8
leaq 0x14d9c0(%rip), %rsi    # 0x1b7034
leaq 0x1529cc(%rip), %rdx    # 0x1bc047
movl $0x294, %ecx            # imm = 0x294
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd1c8(%rsp)
jmp 0x69694
movsd 0xd208(%rsp), %xmm0
xorl %eax, %eax
movl %eax, %esi
leaq 0x14fcf3(%rip), %rdx    # 0x1b939b
movq %rsi, %rdi
movb $0x1, %al
callq 0x8540
movl %eax, 0x808c(%rsp)
movq 0xd0f8(%rsp), %rdi
movq 0xd0d8(%rsp), %rax
movslq (%rax), %rax
shlq $0xa, %rax
addq %rax, %rdi
movl 0x808c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movsd 0xd208(%rsp), %xmm0
leaq 0x14fcab(%rip), %rdx    # 0x1b939b
movb $0x1, %al
callq 0x8540
cmpl $0x0, 0xd2b0(%rsp)
jle 0x6975f
cmpl $0x0, 0xd1c8(%rsp)
jne 0x6974f
movq 0xd0f0(%rsp), %rsi
movq 0xd0d8(%rsp), %rax
movslq (%rax), %rax
shlq $0xa, %rax
addq %rax, %rsi
movq 0xd0f8(%rsp), %rdx
movq 0xd0d8(%rsp), %rax
movslq (%rax), %rax
shlq $0xa, %rax
addq %rax, %rdx
leaq 0x152af8(%rip), %rdi    # 0x1bc23e
movb $0x0, %al
callq 0x8030
jmp 0x6975d
leaq 0x152afd(%rip), %rdi    # 0x1bc253
movb $0x0, %al
callq 0x8030
jmp 0x6975f
jmp 0x69b3f
cmpl $0x0, 0xd2b0(%rsp)
jle 0x6977c
leaq 0x152afc(%rip), %rdi    # 0x1bc271
movb $0x0, %al
callq 0x8030
movslq 0xd21c(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xd1f8(%rsp)
cmpq $0x0, 0xd1f8(%rsp)
jne 0x69811
movslq 0xd21c(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x8088(%rsp)
leaq 0x7880(%rsp), %rdi
movl 0x8088(%rsp), %ecx
leaq 0x14d83b(%rip), %rsi    # 0x1b7004
leaq 0x152ac5(%rip), %rdx    # 0x1bc295
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x7880(%rsp), %r8
leaq 0x14d846(%rip), %rsi    # 0x1b7034
leaq 0x152852(%rip), %rdx    # 0x1bc047
movl $0x2b1, %ecx            # imm = 0x2B1
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movslq 0xd21c(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0xd200(%rsp)
cmpq $0x0, 0xd200(%rsp)
jne 0x698a6
movslq 0xd21c(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x787c(%rsp)
leaq 0x7070(%rsp), %rdi
movl 0x787c(%rsp), %ecx
leaq 0x14d7a6(%rip), %rsi    # 0x1b7004
leaq 0x152a38(%rip), %rdx    # 0x1bc29d
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x7070(%rsp), %r8
leaq 0x14d7b1(%rip), %rsi    # 0x1b7034
leaq 0x1527bd(%rip), %rdx    # 0x1bc047
movl $0x2b4, %ecx            # imm = 0x2B4
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd1f8(%rsp), %rdi
movq 0xd200(%rsp), %rsi
movq 0xd2c0(%rsp), %rcx
leaq 0xd0d8(%rsp), %rdx
callq 0x6ccc0
cmpl $0x1, %eax
jne 0x6992f
leaq 0x6870(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14daf1(%rip), %rsi    # 0x1b73d8
leaq 0x1529b4(%rip), %rdx    # 0x1bc2a2
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x6870(%rsp), %r8
leaq 0x14d728(%rip), %rsi    # 0x1b7034
leaq 0x152734(%rip), %rdx    # 0x1bc047
movl $0x2b9, %ecx            # imm = 0x2B9
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd1f8(%rsp), %rsi
movq 0xd200(%rsp), %rdx
movl 0xd21c(%rsp), %ecx
movq 0xd260(%rsp), %rax
movsd 0x68(%rax), %xmm0
movq 0xd260(%rsp), %rax
movsd 0x70(%rax), %xmm1
movq 0xd2c0(%rsp), %rax
leaq 0x3ea1(%rip), %rdi      # 0x6d810
leaq 0xd0d8(%rsp), %r8
leaq 0xd210(%rsp), %r9
movq %rax, (%rsp)
callq 0x18520
cmpl $0x1, %eax
jne 0x699ee
leaq 0x6070(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14da34(%rip), %rsi    # 0x1b73d8
leaq 0x152924(%rip), %rdx    # 0x1bc2cf
movb $0x0, %al
callq 0x5b9c0
movq 0xd258(%rsp), %rdi
addq $0x382, %rdi            # imm = 0x382
leaq 0x6070(%rsp), %r8
leaq 0x14d664(%rip), %rsi    # 0x1b7034
leaq 0x152670(%rip), %rdx    # 0x1bc047
movl $0x2c7, %ecx            # imm = 0x2C7
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd1c8(%rsp)
movl $0x0, 0xd218(%rsp)
movl 0xd218(%rsp), %eax
cmpl 0xd21c(%rsp), %eax
jge 0x69b25
jmp 0x69a0f
movq 0xd1f8(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorl %eax, %eax
movl %eax, %esi
leaq 0x14f96c(%rip), %rdx    # 0x1b939b
movq %rsi, %rdi
movb $0x1, %al
callq 0x8540
movl %eax, 0x606c(%rsp)
movq 0xd0f8(%rsp), %rdi
movq 0xd0d8(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0xa, %rax
addq %rax, %rdi
movl 0x606c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0xd1f8(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x14f90f(%rip), %rdx    # 0x1b939b
movb $0x1, %al
callq 0x8540
cmpl $0x0, 0xd2b0(%rsp)
jle 0x69b0d
cmpl $0x0, 0xd1c8(%rsp)
jne 0x69afd
movq 0xd0f0(%rsp), %rsi
movq 0xd0d8(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0xa, %rax
addq %rax, %rsi
movq 0xd0f8(%rsp), %rdx
movq 0xd0d8(%rsp), %rax
movslq 0xd218(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0xa, %rax
addq %rax, %rdx
leaq 0x15274a(%rip), %rdi    # 0x1bc23e
movb $0x0, %al
callq 0x8030
jmp 0x69b0b
leaq 0x15274f(%rip), %rdi    # 0x1bc253
movb $0x0, %al
callq 0x8030
jmp 0x69b0d
jmp 0x69b0f
movl 0xd218(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd218(%rsp)
jmp 0x699f9
movq 0xd1f8(%rsp), %rdi
callq 0x8420
movq 0xd200(%rsp), %rdi
callq 0x8420
cmpl $0x1, 0xd2b0(%rsp)
jle 0x69b68
cmpl $0x0, 0xd1c8(%rsp)
jne 0x69b68
movl 0xd210(%rsp), %esi
leaq 0x15280c(%rip), %rdi    # 0x1bc36d
movb $0x0, %al
callq 0x8030
movl 0xd1c8(%rsp), %eax
movw %ax, %cx
movq 0xd258(%rsp), %rax
movw %cx, 0x380(%rax)
leaq 0xd0d8(%rsp), %rdi
addq $0x8, %rdi
movq 0xd268(%rsp), %rsi
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %edx
subl 0xd21c(%rsp), %edx
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %ecx
callq 0x3aca0
leaq 0xd0d8(%rsp), %rdi
addq $0x8, %rdi
callq 0x382b0
cmpl $0x1, %eax
jne 0x69c2c
leaq 0x5860(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14d7f4(%rip), %rsi    # 0x1b73d8
leaq 0x1527b4(%rip), %rdx    # 0x1bc39f
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x5860(%rsp), %r8
leaq 0x14d42b(%rip), %rsi    # 0x1b7034
leaq 0x152437(%rip), %rdx    # 0x1bc047
movl $0x2eb, %ecx            # imm = 0x2EB
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd220(%rsp), %rdi
callq 0x8420
movq 0xd0d8(%rsp), %rdi
callq 0x8420
movq 0xd108(%rsp), %rdi
callq 0x8420
movq 0xd110(%rsp), %rdi
callq 0x8420
movq 0xd268(%rsp), %rdi
movq 0xd2c0(%rsp), %r8
leaq 0x178f91(%rip), %rsi    # 0x1e2c08
leaq 0xd230(%rsp), %rdx
leaq 0xd23c(%rsp), %rcx
callq 0x385d0
cmpl $0x1, %eax
jne 0x69cf0
leaq 0x5060(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14d730(%rip), %rsi    # 0x1b73d8
leaq 0x152707(%rip), %rdx    # 0x1bc3b6
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x5060(%rsp), %r8
leaq 0x14d367(%rip), %rsi    # 0x1b7034
leaq 0x152373(%rip), %rdx    # 0x1bc047
movl $0x2f6, %ecx            # imm = 0x2F6
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd268(%rsp), %rdi
movq 0xd2c0(%rsp), %r8
leaq 0x1526e6(%rip), %rsi    # 0x1bc3ed
leaq 0xd228(%rsp), %rdx
leaq 0xd238(%rsp), %rcx
callq 0x385d0
cmpl $0x1, %eax
jne 0x69d80
leaq 0x4860(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14d6a0(%rip), %rsi    # 0x1b73d8
leaq 0x1526b1(%rip), %rdx    # 0x1bc3f0
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x4860(%rsp), %r8
leaq 0x14d2d7(%rip), %rsi    # 0x1b7034
leaq 0x1522e3(%rip), %rdx    # 0x1bc047
movl $0x2f9, %ecx            # imm = 0x2F9
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
cmpl $0x1, 0xd23c(%rsp)
jne 0x69e09
cmpl $0x1, 0xd238(%rsp)
jne 0x69e09
leaq 0x4060(%rsp), %rdi
leaq 0x152680(%rip), %rsi    # 0x1bc423
movb $0x0, %al
callq 0x5b9c0
leaq 0x3860(%rsp), %rdi
leaq 0x4060(%rsp), %rcx
leaq 0x14d2c1(%rip), %rsi    # 0x1b7082
leaq 0x152687(%rip), %rdx    # 0x1bc44f
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x3860(%rsp), %r8
leaq 0x14d24e(%rip), %rsi    # 0x1b7034
leaq 0x15225a(%rip), %rdx    # 0x1bc047
movl $0x2fc, %ecx            # imm = 0x2FC
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
cmpl $0x1, 0xd23c(%rsp)
je 0x69e21
cmpl $0x1, 0xd238(%rsp)
jne 0x6a46b
movq 0xd2b8(%rsp), %rax
movl $0x1, (%rax)
movq 0xd268(%rsp), %rdi
movq 0xd2c0(%rsp), %rdx
movl $0x1, %esi
callq 0x3a9b0
cmpl $0x1, %eax
jne 0x69ead
leaq 0x3060(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14d573(%rip), %rsi    # 0x1b73d8
leaq 0x15260a(%rip), %rdx    # 0x1bc476
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x3060(%rsp), %r8
leaq 0x14d1aa(%rip), %rsi    # 0x1b7034
leaq 0x1521b6(%rip), %rdx    # 0x1bc047
movl $0x303, %ecx            # imm = 0x303
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd268(%rsp), %rdi
leaq 0xd0d8(%rsp), %rsi
addq $0x8, %rsi
movq 0xd2c0(%rsp), %rdx
callq 0x3ad70
cmpl $0x1, %eax
jne 0x69f32
leaq 0x2860(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14d4ee(%rip), %rsi    # 0x1b73d8
leaq 0x1521ed(%rip), %rdx    # 0x1bc0de
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x2860(%rsp), %r8
leaq 0x14d125(%rip), %rsi    # 0x1b7034
leaq 0x152131(%rip), %rdx    # 0x1bc047
movl $0x306, %ecx            # imm = 0x306
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movl $0x1, 0xd118(%rsp)
movl $0x4, %edi
callq 0x8460
movq %rax, 0xd0d8(%rsp)
cmpq $0x0, 0xd0d8(%rsp)
jne 0x69fc3
movl $0x4, 0x285c(%rsp)
leaq 0x2050(%rsp), %rdi
movl 0x285c(%rsp), %ecx
leaq 0x14d089(%rip), %rsi    # 0x1b7004
leaq 0x15219b(%rip), %rdx    # 0x1bc11d
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x2050(%rsp), %r8
leaq 0x14d094(%rip), %rsi    # 0x1b7034
leaq 0x1520a0(%rip), %rdx    # 0x1bc047
movl $0x30b, %ecx            # imm = 0x30B
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movl $0x4, %edi
callq 0x8460
movq %rax, 0xd108(%rsp)
cmpq $0x0, 0xd108(%rsp)
jne 0x6a049
movl $0x4, 0x204c(%rsp)
leaq 0x1840(%rsp), %rdi
movl 0x204c(%rsp), %ecx
leaq 0x14d003(%rip), %rsi    # 0x1b7004
leaq 0x152132(%rip), %rdx    # 0x1bc13a
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x1840(%rsp), %r8
leaq 0x14d00e(%rip), %rsi    # 0x1b7034
leaq 0x15201a(%rip), %rdx    # 0x1bc047
movl $0x30e, %ecx            # imm = 0x30E
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movl $0x8, %edi
callq 0x8460
movq %rax, 0xd110(%rsp)
cmpq $0x0, 0xd110(%rsp)
jne 0x6a0cf
movl $0x8, 0x183c(%rsp)
leaq 0x1030(%rsp), %rdi
movl 0x183c(%rsp), %ecx
leaq 0x14cf7d(%rip), %rsi    # 0x1b7004
leaq 0x1520bc(%rip), %rdx    # 0x1bc14a
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x1030(%rsp), %r8
leaq 0x14cf88(%rip), %rsi    # 0x1b7034
leaq 0x151f94(%rip), %rdx    # 0x1bc047
movl $0x311, %ecx            # imm = 0x311
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
cmpl $0x1, 0xd23c(%rsp)
jne 0x6a0fe
movq 0xd108(%rsp), %rax
movl $0x8, (%rax)
movsd 0xd230(%rsp), %xmm0
movq 0xd110(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x6a12d
cmpl $0x1, 0xd238(%rsp)
jne 0x6a12b
movq 0xd108(%rsp), %rax
movl $0x9, (%rax)
movsd 0xd228(%rsp), %xmm0
movq 0xd110(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x6a12d
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movq 0xd0d8(%rsp), %rax
movl %ecx, (%rax)
movl $0x4, 0xd11c(%rsp)
movq 0xd0f0(%rsp), %rdi
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
cltq
shlq $0xa, %rax
addq %rax, %rdi
leaq 0x15fa26(%rip), %rsi    # 0x1c9b9c
callq 0x8370
cmpl $0x0, 0xd2b0(%rsp)
jle 0x6a1b6
movl 0xd23c(%rsp), %ecx
leaq 0x15225a(%rip), %rsi    # 0x1bc3ed
leaq 0x178a6e(%rip), %rax    # 0x1e2c08
cmpl $0x1, %ecx
cmoveq %rax, %rsi
leaq 0x152006(%rip), %rdi    # 0x1bc1ae
leaq 0x15f9ed(%rip), %rdx    # 0x1c9b9c
movb $0x0, %al
callq 0x8030
cmpl $0x1, 0xd23c(%rsp)
jne 0x6a1e8
movsd 0x151470(%rip), %xmm0   # 0x1bb638
mulsd 0xd230(%rsp), %xmm0
movsd 0x151467(%rip), %xmm1   # 0x1bb640
divsd %xmm1, %xmm0
movsd %xmm0, 0x1028(%rsp)
jmp 0x6a21a
cmpl $0x1, 0xd238(%rsp)
jne 0x6a218
movsd 0x15143e(%rip), %xmm0   # 0x1bb638
mulsd 0xd228(%rsp), %xmm0
movsd 0x151425(%rip), %xmm1   # 0x1bb630
divsd %xmm1, %xmm0
movsd %xmm0, 0x1028(%rsp)
jmp 0x6a21a
movq 0xd2c0(%rsp), %r8
leaq 0x1028(%rsp), %rdi
movl $0x1, %esi
leaq 0xd0d8(%rsp), %rdx
leaq 0x1020(%rsp), %rcx
callq 0x6d810
cmpl $0x1, %eax
jne 0x6a2a8
leaq 0x820(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14d178(%rip), %rsi    # 0x1b73d8
leaq 0x15222d(%rip), %rdx    # 0x1bc494
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x820(%rsp), %r8
leaq 0x14cdaf(%rip), %rsi    # 0x1b7034
leaq 0x151dbb(%rip), %rdx    # 0x1bc047
movl $0x33b, %ecx            # imm = 0x33B
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd110(%rsp), %rax
movsd (%rax), %xmm0
divsd 0x1020(%rsp), %xmm0
movq 0xd110(%rsp), %rax
movsd (%rax), %xmm1
divsd 0x1020(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd 0x1028(%rsp), %xmm0
movsd %xmm0, 0x1028(%rsp)
movsd 0x1028(%rsp), %xmm0
xorl %eax, %eax
movl %eax, %esi
leaq 0x14f09f(%rip), %rdx    # 0x1b939b
movq %rsi, %rdi
movb $0x1, %al
callq 0x8540
movl %eax, 0x81c(%rsp)
movq 0xd0f8(%rsp), %rdi
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
cltq
shlq $0xa, %rax
addq %rax, %rdi
movl 0x81c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movsd 0x1028(%rsp), %xmm0
leaq 0x14f052(%rip), %rdx    # 0x1b939b
movb $0x1, %al
callq 0x8540
cmpl $0x0, 0xd2b0(%rsp)
jle 0x6a3a6
movq 0xd0f0(%rsp), %rsi
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
cltq
shlq $0xa, %rax
addq %rax, %rsi
movq 0xd0f8(%rsp), %rdx
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
cltq
shlq $0xa, %rax
addq %rax, %rdx
leaq 0x151e9f(%rip), %rdi    # 0x1bc23e
movb $0x0, %al
callq 0x8030
leaq 0xd0d8(%rsp), %rdi
addq $0x8, %rdi
movq 0xd268(%rsp), %rsi
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %edx
subl $0x1, %edx
movq 0xd268(%rsp), %rax
movl 0x8(%rax), %ecx
callq 0x3aca0
leaq 0xd0d8(%rsp), %rdi
addq $0x8, %rdi
callq 0x382b0
cmpl $0x1, %eax
jne 0x6a444
leaq 0x10(%rsp), %rdi
movq 0xd2c0(%rsp), %rcx
leaq 0x14cfd6(%rip), %rsi    # 0x1b73d8
leaq 0x151f96(%rip), %rdx    # 0x1bc39f
movb $0x0, %al
callq 0x5b9c0
movq 0xd2c0(%rsp), %rdi
leaq 0x10(%rsp), %r8
leaq 0x14cc10(%rip), %rsi    # 0x1b7034
leaq 0x151c1c(%rip), %rdx    # 0x1bc047
movl $0x34b, %ecx            # imm = 0x34B
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0xd274(%rsp)
jmp 0x6a476
movq 0xd0d8(%rsp), %rdi
callq 0x8420
movq 0xd108(%rsp), %rdi
callq 0x8420
movq 0xd110(%rsp), %rdi
callq 0x8420
movl $0x0, 0xd274(%rsp)
movl 0xd274(%rsp), %eax
addq $0xd278, %rsp           # imm = 0xD278
retq
nopw %cs:(%rax,%rax)