// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/algorithm.c
// Function: prepare_supervised_algorithm_parameters
void* prepare_supervised_algorithm_parameters(int algorithm)
{
 /*!Last Changed 11.08.2007 added SVMTREE algorithm*/
 /*!Last Changed 11.08.2007 added NAIVEBAYES algorithm*/
 /*!Last Changed 05.08.2007 added QDACLASS algorithm*/
 /*!Last Changed 02.04.2007 added HMM algorithm*/
 /*!Last Changed 14.08.2005*/
 Knn_parameterptr pknn;
 C45_parameterptr pc45;
 Ldaclass_parameterptr plda;
 Ripper_parameterptr prip;
 Mlpparametersptr pmlp;
 Softregtree_parameterptr psoftregtree;
 Regtree_parameterptr pregtree;
 Multildt_parameterptr pmultildt;
 Quantizereg_parameterptr pqua;
 Regrule_parameterptr pregrule;
 Logistic_parameterptr plogistic;
 Svm_parameterptr psvm;
 Svmtree_parameterptr psvmtree;
 Nodeboundedtree_parameterptr pnbtree;
 Hmm_parameterptr phmm;
 Rbf_parameterptr prbf;
 Gprocess_parameterptr pgprocess;
 Randomforest_parameterptr prf;
 Kforest_parameterptr pkf;
 Cn2_parameterptr pcn2;
 Lerils_parameterptr plerils;
 Svm_simplex_parameterptr ssvm;
 switch (algorithm)
  {
   case SELECTMAX     :
   case ONEFEATURE    :
   case NEARESTMEAN   :
   case GAUSSIAN      :
   case SELECTAVERAGE :
   case LINEARREG     :
   case NAIVEBAYES    :
   case QDACLASS      :
   case C45RULES      :return NULL;
   case QUANTIZEREG   :pqua = safemalloc(sizeof(Quantizereg_parameter), "prepare_supervised_algorithm_parameters", 4);
                       pqua->partitioncount = get_parameter_i("partitioncount");
                       return pqua;
   case KNN           :
   case KNNREG        :pknn = safemalloc(sizeof(Knn_parameter), "prepare_supervised_algorithm_parameters", 6);
                       pknn->nearcount = get_parameter_i("nearcount");
                       return pknn;
   case GPROCESSREG   :pgprocess = safemalloc(sizeof(Gprocess_parameter), "prepare_supervised_algorithm_parameters", 6);
                       pgprocess->sigma = get_parameter_f("sigma");
                       pgprocess->kernel_type = get_parameter_l("kerneltype");
                       pgprocess->coef0 = get_parameter_f("svmcoef0");
                       pgprocess->degree = get_parameter_i("svmdegree");
                       pgprocess->gamma = get_parameter_f("svmgamma");
                       return pgprocess;
   case LDT           :
   case C45           :
   case CART          :
   case KTREE         :pc45 = safemalloc(sizeof(C45_parameter), "prepare_supervised_algorithm_parameters", 9);
                       pc45->prunetype = get_parameter_l("prunetype");
                       pc45->prunemodel = get_parameter_l("prunemodel");
                       pc45->pruningthreshold = get_parameter_f("pruningthreshold");
                       return pc45;
   case RANDOMFOREST  :prf = safemalloc(sizeof(Randomforest_parameter), "prepare_supervised_algorithm_parameters", 12);
                       prf->featuresize = get_parameter_i("featuresize");
                       prf->forestsize = get_parameter_i("forestsize");
                       return prf;
   case KFOREST       :pkf = safemalloc(sizeof(Kforest_parameter), "prepare_supervised_algorithm_parameters", 12);
                       pkf->featuresize = get_parameter_i("featuresize");
                       pkf->forestsize = get_parameter_i("forestsize");
                       pkf->k = get_parameter_i("smallsetsize");
                       return pkf;
   case SVMTREE       :psvmtree = safemalloc(sizeof(Svmtree_parameter), "prepare_supervised_algorithm_parameters", 9);
                       psvmtree->c45param.prunetype = get_parameter_l("prunetype");
                       psvmtree->c45param.pruningthreshold = get_parameter_f("pruningthreshold");
                       psvmtree->multiclasstype = get_parameter_l("multiclasstype");
                       return psvmtree;
   case NBTREE        :pnbtree = safemalloc(sizeof(Nodeboundedtree_parameter), "prepare_supervised_algorithm_parameters", 13);
                       pnbtree->nodecount = get_parameter_i("nodecount");
                       pnbtree->model = get_parameter_l("modelselectionmethod");
                       if (get_parameter_s("model_per_level") != NULL)
                        {
                         if (strlen(get_parameter_s("model_per_level")) > MAX_MODEL_STRING_SIZE)
                           printf(m1338);
                         strcpy(pnbtree->modelstring, get_parameter_s("model_per_level"));
                        }
                       pnbtree->variance_explained = get_parameter_f("variance_explained");
                       pnbtree->prunetype = get_parameter_l("prunetype");    
                       pnbtree->partitioncount = get_parameter_i("partitioncount");
                       pnbtree->usediscrete = get_parameter_o("usediscrete");
                       pnbtree->vccalculationtype = get_parameter_l("vccalculationtype");
                       return pnbtree;
   case LDACLASS      :plda = safemalloc(sizeof(Ldaclass_parameter), "prepare_supervised_algorithm_parameters", 13);
                       plda->variance_explained = get_parameter_f("variance_explained");
                       return plda;
   case LOGISTIC      :plogistic = safemalloc(sizeof(Logistic_parameter), "prepare_supervised_algorithm_parameters", 16);
                       plogistic->etadecrease = get_parameter_f("etadecrease");
                       plogistic->learning_rate = get_parameter_f("learning_rate");
                       plogistic->perceptron_run = get_parameter_i("perceptronrun");
                       return plogistic;
   case IREP          :
   case IREP2         :
   case RIPPER        :
   case MULTIRIPPER   :
   case HYBRIDRIPPER  :
   case REXRIPPER     :prip = safemalloc(sizeof(Ripper_parameter), "prepare_supervised_algorithm_parameters", 16);
                       if (get_parameter_s("classpermutation") != NULL)
                        {
                         if (strlen(get_parameter_s("classpermutation")) > MAX_CLASS_PERMUTATION_SIZE)
                           printf(m1339);
                         strcpy(prip->classpermutation, get_parameter_s("classpermutation"));
                        }
                       else
                         strcpy(prip->classpermutation, "");
                       prip->optimizecount = get_parameter_i("optimizecount");
                       prip->rexenabled = NO;
                       prip->rulesordered = YES;
                       prip->smallset = get_parameter_o("smallset");
                       prip->smallsetsize = get_parameter_i("smallsetsize");
                       prip->usefisher = get_parameter_o("usefisher");
                       prip->withoutoutliers = get_parameter_o("withoutoutliers");
                       prip->confidencelevel = get_parameter_f("confidencelevel");
                       prip->correctiontype = get_parameter_l("correctiontype");
                       prip->conditiontype = UNIVARIATE_CONDITION;
                       prip->modelselectionmethod = get_parameter_l("modelselectionmethod");
                       prip->nearcount = get_parameter_i("nearcount");
                       prip->multivariatealgorithm = get_parameter_l("multivariatealgorithm");
                       prip->variancerange = get_parameter_f("variancerange");
                       prip->variance_explained = get_parameter_f("variance_explained");
                       prip->classorderoptimize = get_parameter_o("classorderoptimize");
                       break;
   case CN2           :pcn2 = safemalloc(sizeof(Cn2_parameter), "prepare_supervised_algorithm_parameters", 31);
                       pcn2->maxstar = get_parameter_i("beamsize");
                       pcn2->confidencelevel = get_parameter_f("confidencelevel");
                       if (get_parameter_s("classpermutation") != NULL)
                        {
                         if (strlen(get_parameter_s("classpermutation")) > MAX_CLASS_PERMUTATION_SIZE)
                           printf(m1339);
                         strcpy(pcn2->classpermutation, get_parameter_s("classpermutation"));
                        }
                       else
                         strcpy(pcn2->classpermutation, "");
                       return pcn2;
                       break;
   case LERILS        :plerils = safemalloc(sizeof(Lerils_parameter), "prepare_supervised_algorithm_parameters", 36);
                       plerils->flip_probability = get_parameter_f("mutationprobability");
                       plerils->pool_size = get_parameter_i("populationsize");
                       plerils->restarts = get_parameter_i("restarts");
                       return plerils;
   case RBF           :
   case RBFREG        :prbf = safemalloc(sizeof(Rbf_parameter), "prepare_supervised_algorithm_parameters", 34);
                       if (current_dataset->classno == 0)
                         prbf->output = 1;
                       else
                         prbf->output = current_dataset->classno;
                       prbf->input = current_dataset->multifeaturecount - 1;
                       prbf->hidden = ((int *) get_parameter_a("hiddennodes"))[0];
                       prbf->epochs = get_parameter_i("perceptronrun");
                       prbf->alpha = get_parameter_f("alpha");
                       prbf->eta = get_parameter_f("learning_rate");
                       prbf->initialeta = prbf->eta;
                       prbf->etadecrease = get_parameter_f("etadecrease");
                       prbf->randrange = 0.01;
                       return prbf;
   case MLPGENERIC    :
   case MLPGENERICREG :pmlp = safemalloc(sizeof(Mlpparameters), "prepare_supervised_algorithm_parameters", 34);
                       *pmlp = prepare_Mlpparameters(NULL, NULL, get_parameter_o("weightdecay"), get_parameter_f("decayalpha"), get_parameter_i("hiddenlayers"), (int *) get_parameter_a("hiddennodes"), 0, 0.0, 0.0, get_parameter_i("maxhidden"), get_algorithm_type(algorithm));
                       return pmlp;
   case DNC           :
   case DNCREG        :pmlp = safemalloc(sizeof(Mlpparameters), "prepare_supervised_algorithm_parameters", 38);
                       *pmlp = prepare_Mlpparameters(NULL, NULL, get_parameter_o("weightdecay"), get_parameter_f("decayalpha"), 1, NULL, get_parameter_i("windowsize"), get_parameter_f("errorthreshold"), get_parameter_f("errordropratio"), get_parameter_i("maxhidden"), get_algorithm_type(algorithm));
                       return pmlp;
   case SVMREGTREE    :
   case REGTREE       :
   case REGSTUMP      :pregtree = safemalloc(sizeof(Regtree_parameter), "prepare_supervised_algorithm_parameters", 37);
                       pregtree->correctiontype = get_parameter_l("correctiontype");
                       pregtree->leaftype = get_parameter_l("leaftype");
                       pregtree->modelselectionmethod = get_parameter_l("modelselectionmethod");
                       pregtree->nearcount = get_parameter_i("nearcount");
                       pregtree->prunetype = get_parameter_l("prunetype");
                       pregtree->pruningthreshold = get_parameter_f("pruningthreshold");
                       pregtree->sigma = get_parameter_f("sigmaestimate");
                       return pregtree;
   case SOFTREGTREE   :
   case SOFTTREE      :
   case SOFTSTUMP     :
   case SOFTREGSTUMP  :psoftregtree = safemalloc(sizeof(Softregtree_parameter), "prepare_supervised_algorithm_parameters", 37);
                       psoftregtree->leaftype = get_parameter_l("leaftype");
                       psoftregtree->epochs = get_parameter_i("perceptronrun");
                       psoftregtree->learningrate = get_parameter_f("learning_rate");
                       psoftregtree->etadecrease = get_parameter_f("etadecrease");
                       psoftregtree->alpha = get_parameter_f("alpha");
                       psoftregtree->regularization = get_parameter_l("regularization");
                       return psoftregtree;
   case REGRULE       :pregrule = safemalloc(sizeof(Regrule_parameter), "prepare_supervised_algorithm_parameters", 45);
                       pregrule->correctiontype = get_parameter_l("correctiontype");
                       pregrule->leaftype = get_parameter_l("leaftype");
                       pregrule->modelselectionmethod = get_parameter_l("modelselectionmethod");
                       pregrule->optimizecount = get_parameter_i("optimizecount");
                       pregrule->sigma = get_parameter_f("sigmaestimate");
                       return pregrule;
   case MULTILDT      :
   case OMNILDT       :pmultildt = safemalloc(sizeof(Multildt_parameter), "prepare_supervised_algorithm_parameters", 45);
                       pmultildt->c45param.prunetype = get_parameter_l("prunetype");
                       pmultildt->c45param.pruningthreshold = get_parameter_f("pruningthreshold");
                       pmultildt->conditiontype = MULTIVARIATE_CONDITION;
                       pmultildt->correctiontype = get_parameter_l("correctiontype");
                       pmultildt->modelselectionmethod = get_parameter_l("modelselectionmethod");
                       pmultildt->variance_explained = get_parameter_f("variance_explained");
                       pmultildt->variancerange = get_parameter_f("variancerange");
                       pmultildt->a1 = get_parameter_f("srma1");
                       pmultildt->a2 = get_parameter_f("srma2");
                       break;
   case SVM           :psvm = safemalloc(sizeof(Svm_parameter), "prepare_supervised_algorithm_parameters", 46);
                       prepare_svm_parameters(psvm, C_SVC);
                       return psvm;
   case SIMPLEXSVM    :
   case SIMPLEXSVMREG :ssvm = safemalloc(sizeof(Svm_simplex_parameter), "prepare_supervised_algorithm_parameters", 46);
                       ssvm->C = get_parameter_f("svmC");
                       ssvm->epsilon = get_parameter_f("svmepsilon");
                       ssvm->kernel.type = get_parameter_l("kerneltype");
                       ssvm->kernel.coef0 = get_parameter_f("svmcoef0");
                       ssvm->kernel.degree = get_parameter_i("svmdegree");
                       ssvm->kernel.gamma = get_parameter_f("svmgamma");
                       return ssvm;
   case SVMREG        :psvm = safemalloc(sizeof(Svm_parameter), "prepare_supervised_algorithm_parameters", 46);
                       prepare_svm_parameters(psvm, EPSILON_SVR);
                       return psvm;
   case HMM           :phmm = safemalloc(sizeof(Hmm_parameter), "prepare_supervised_algorithm_parameters", 64);                      
                       phmm->hmmtype = get_parameter_l("hmmtype");
                       phmm->statetype = get_parameter_l("hmmstatetype");
                       phmm->iteration = get_parameter_i("perceptronrun");
                       phmm->weightfreezing = get_parameter_o("weightfreezing");
                       phmm->learningtype = get_parameter_l("hmmlearningtype");
                       phmm->statecounts = get_parameter_a("statecounts");
                       phmm->componentcounts = get_parameter_a("componentcounts");
                       return phmm;
  }
 switch (algorithm)
  {
   case IREP         :
   case IREP2        :
   case RIPPER       :return prip;
   case MULTIRIPPER  :prip->conditiontype = MULTIVARIATE_CONDITION;
                      prip->multivariatealgorithm = get_parameter_l("multivariatealgorithm");
                      return prip;
   case HYBRIDRIPPER :prip->conditiontype = HYBRID_CONDITION;
                      prip->multivariatealgorithm = get_parameter_l("multivariatealgorithm");
                      return prip;
   case REXRIPPER    :prip->rexenabled = YES;
                      prip->rulesordered = NO;
                      return prip;
   case MULTILDT     :return pmultildt;
   case OMNILDT      :pmultildt->conditiontype = HYBRID_CONDITION;
                      return pmultildt;
  }
 return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edi, %r14d
xorl %ebx, %ebx
leal -0x3e8(%r14), %r13d
cmpl $0x28, %r13d
ja 0x5bde
leaq 0x9f85f(%rip), %rax     # 0xa53c4
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x9fc86(%rip), %rsi     # 0xa57fb
movl $0x60, %edi
movl $0x10, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9fd66(%rip), %rdi     # 0xa58f4
callq 0x54a6f
testq %rax, %rax
je 0x5d3d
leaq 0x9fd51(%rip), %rdi     # 0xa58f4
callq 0x54a6f
movq %rax, %rdi
callq 0x4190
cmpq $0xc, %rax
jb 0x5bc2
leaq 0xa0080(%rip), %rdi     # 0xa5c3d
callq 0x4090
leaq 0x9fd2b(%rip), %rdi     # 0xa58f4
callq 0x54a6f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4270
jmp 0x5d40
leal -0x7d0(%r14), %eax
cmpl $0x10, %eax
ja 0x5ebe
leaq 0x9f873(%rip), %rcx     # 0xa5468
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9fbf6(%rip), %rsi     # 0xa57fb
movl $0x28, %edi
movl $0x25, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9fd1a(%rip), %rdi     # 0xa5938
callq 0x54afc
movl %eax, 0x1c(%rbx)
leaq 0x9fde9(%rip), %rdi     # 0xa5a16
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9fb9b(%rip), %rdi     # 0xa57d6
callq 0x54afc
movl %eax, 0x8(%rbx)
leaq 0x9fbe8(%rip), %rdi     # 0xa5832
callq 0x54920
movl %eax, 0x18(%rbx)
leaq 0x9fad9(%rip), %rdi     # 0xa5732
callq 0x54afc
movl %eax, 0x4(%rbx)
leaq 0x9fb19(%rip), %rdi     # 0xa5781
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
leaq 0x9fda6(%rip), %rdi     # 0xa5a1f
jmp 0x65ab
leaq 0x9fb76(%rip), %rsi     # 0xa57fb
movl $0x10, %edi
movl $0x9, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9fa94(%rip), %rdi     # 0xa5732
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9fbbd(%rip), %rdi     # 0xa5869
callq 0x54afc
movl %eax, 0x4(%rbx)
leaq 0x9fac6(%rip), %rdi     # 0xa5781
jmp 0x5f5b
leaq 0x9fb34(%rip), %rsi     # 0xa57fb
movl $0x28, %edi
movl $0x25, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9fd36(%rip), %rdi     # 0xa5a16
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9fbf8(%rip), %rdi     # 0xa58e6
callq 0x54920
movl %eax, 0x4(%rbx)
leaq 0x9fbdb(%rip), %rdi     # 0xa58d8
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
leaq 0x9fbbe(%rip), %rdi     # 0xa58cc
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
leaq 0x9fcb1(%rip), %rdi     # 0xa59d0
callq 0x549ba
movsd %xmm0, 0x18(%rbx)
leaq 0x9fcfd(%rip), %rdi     # 0xa5a2d
callq 0x54afc
movl %eax, 0x20(%rbx)
jmp 0x66fd
movb $0x0, (%rbx)
leaq 0x9fa81(%rip), %rdi     # 0xa57c8
callq 0x54920
movl %eax, 0x10(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x24(%rbx)
movl $0x1, 0xc(%rbx)
leaq 0x9fba3(%rip), %rdi     # 0xa5905
callq 0x54bec
movl %eax, 0x18(%rbx)
leaq 0x9fb03(%rip), %rdi     # 0xa5874
callq 0x54920
movl %eax, 0x1c(%rbx)
leaq 0x9fb8e(%rip), %rdi     # 0xa590e
callq 0x54bec
movl %eax, 0x14(%rbx)
leaq 0x9fb89(%rip), %rdi     # 0xa5918
callq 0x54bec
movl %eax, 0x20(%rbx)
leaq 0x9fb8a(%rip), %rdi     # 0xa5928
callq 0x549ba
movsd %xmm0, 0x30(%rbx)
leaq 0x9fb89(%rip), %rdi     # 0xa5938
callq 0x54afc
movl %eax, 0x3c(%rbx)
movl %ebp, 0x28(%rbx)
leaq 0x9fa15(%rip), %rdi     # 0xa57d6
callq 0x54afc
movl %eax, 0x38(%rbx)
leaq 0x9fa62(%rip), %rdi     # 0xa5832
callq 0x54920
movl %eax, 0x40(%rbx)
leaq 0x9fb68(%rip), %rdi     # 0xa5947
callq 0x54afc
movl %eax, 0x2c(%rbx)
leaq 0x9fb6f(%rip), %rdi     # 0xa595d
callq 0x549ba
movsd %xmm0, 0x48(%rbx)
leaq 0x9fa9c(%rip), %rdi     # 0xa589b
callq 0x549ba
movsd %xmm0, 0x50(%rbx)
leaq 0x9fb5b(%rip), %rdi     # 0xa596b
callq 0x54bec
movl %eax, 0x58(%rbx)
jmp 0x5ebe
leaq 0x9f9d7(%rip), %rsi     # 0xa57fb
movl $0x40, %edi
movl $0x2d, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f8f5(%rip), %rdi     # 0xa5732
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9f936(%rip), %rdi     # 0xa5781
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
movl $0x1, 0x2c(%rbx)
leaq 0x9fad5(%rip), %rdi     # 0xa5938
callq 0x54afc
movl %eax, 0x28(%rbx)
leaq 0x9f964(%rip), %rdi     # 0xa57d6
callq 0x54afc
movl %eax, 0x18(%rbx)
leaq 0x9fa1a(%rip), %rdi     # 0xa589b
callq 0x549ba
movsd %xmm0, 0x20(%rbx)
leaq 0x9facb(%rip), %rdi     # 0xa595d
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
leaq 0x9fb99(%rip), %rdi     # 0xa5a3c
callq 0x549ba
movsd %xmm0, 0x30(%rbx)
leaq 0x9fb8e(%rip), %rdi     # 0xa5a42
callq 0x549ba
movsd %xmm0, 0x38(%rbx)
addl $0xfffffc12, %r14d      # imm = 0xFFFFFC12
cmpl $0x9, %r14d
ja 0x61a4
leaq 0x9f5d6(%rip), %rax     # 0xa54ac
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x1, 0x28(%rbx)
jmp 0x6171
leaq 0x9f909(%rip), %rsi     # 0xa57fb
movl $0x30, %edi
movl $0x2e, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f8a0(%rip), %rdi     # 0xa57ab
callq 0x549ba
movsd %xmm0, 0x20(%rbx)
leaq 0x9fb2c(%rip), %rdi     # 0xa5a48
callq 0x549ba
movsd %xmm0, 0x28(%rbx)
leaq 0x9f915(%rip), %rdi     # 0xa5842
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9f912(%rip), %rdi     # 0xa584d
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
leaq 0x9f90a(%rip), %rdi     # 0xa5856
callq 0x54920
movl %eax, 0x4(%rbx)
leaq 0x9f905(%rip), %rdi     # 0xa5860
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
jmp 0x66fd
leaq 0x9f88a(%rip), %rsi     # 0xa57fb
movl $0x90, %edi
movl $0x22, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9fa35(%rip), %rdi     # 0xa59bf
callq 0x54bec
movl %eax, %ebp
leaq 0x9fa33(%rip), %rdi     # 0xa59cb
callq 0x549ba
movsd %xmm0, (%rsp)
leaq 0x9fa2d(%rip), %rdi     # 0xa59d6
callq 0x54920
movl %eax, %r15d
leaq 0x9f9fb(%rip), %rdi     # 0xa59b3
callq 0x54c89
movq %rax, %r12
leaq 0x9fa1c(%rip), %rdi     # 0xa59e3
callq 0x54920
xorl %r10d, %r10d
cmpl $0x29, %r13d
jb 0x6681
addl $0xfffff830, %r14d      # imm = 0xFFFFF830
xorl %ecx, %ecx
cmpl %ecx, %r14d
je 0x667b
incl %ecx
cmpl $0x11, %ecx
jne 0x5fe2
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
jmp 0x6681
leaq 0x9f7f7(%rip), %rsi     # 0xa57fb
movl $0x4, %edi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f815(%rip), %rdi     # 0xa5832
jmp 0x65da
leaq 0x9f7d2(%rip), %rsi     # 0xa57fb
movl $0x90, %edi
movl $0x26, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f97d(%rip), %rdi     # 0xa59bf
callq 0x54bec
movl %eax, %ebp
leaq 0x9f97b(%rip), %rdi     # 0xa59cb
callq 0x549ba
movsd %xmm0, (%rsp)
leaq 0x9f98c(%rip), %rdi     # 0xa59ed
callq 0x54920
movl %eax, %r15d
leaq 0x9f988(%rip), %rdi     # 0xa59f8
callq 0x549ba
movsd %xmm0, 0x10(%rsp)
leaq 0x9f985(%rip), %rdi     # 0xa5a07
callq 0x549ba
movsd %xmm0, 0x8(%rsp)
leaq 0x9f94f(%rip), %rdi     # 0xa59e3
callq 0x54920
xorl %r10d, %r10d
cmpl $0x29, %r13d
jb 0x66b2
addl $0xfffff830, %r14d      # imm = 0xFFFFF830
xorl %ecx, %ecx
cmpl %ecx, %r14d
je 0x66ac
incl %ecx
cmpl $0x11, %ecx
jne 0x60af
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
jmp 0x66b2
leaq 0x9f72a(%rip), %rsi     # 0xa57fb
movl $0x40, %edi
movl $0x22, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0xcf786(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %ecx
cmpl $0x1, %ecx
adcl $0x0, %ecx
movl %ecx, (%rbx)
movl 0x1c0(%rax), %eax
decl %eax
movl %eax, 0x8(%rbx)
leaq 0x9f8a9(%rip), %rdi     # 0xa59b3
callq 0x54c89
movl (%rax), %eax
movl %eax, 0x4(%rbx)
leaq 0x9f7cb(%rip), %rdi     # 0xa58e6
callq 0x54920
movl %eax, 0xc(%rbx)
leaq 0x9f8a6(%rip), %rdi     # 0xa59d0
callq 0x549ba
movsd %xmm0, 0x38(%rbx)
leaq 0x9f79d(%rip), %rdi     # 0xa58d8
callq 0x549ba
movsd %xmm0, 0x28(%rbx)
movsd %xmm0, 0x18(%rbx)
leaq 0x9f77b(%rip), %rdi     # 0xa58cc
callq 0x549ba
movsd %xmm0, 0x30(%rbx)
movabsq $0x3f847ae147ae147b, %rax # imm = 0x3F847AE147AE147B
jmp 0x622a
movl $0x2, 0x28(%rbx)
leaq 0x9f7cf(%rip), %rdi     # 0xa5947
callq 0x54afc
movl %eax, 0x2c(%rbx)
jmp 0x66fd
movl $0x1, 0x24(%rbx)
movl $0x0, 0xc(%rbx)
jmp 0x66fd
movl $0x2, 0x2c(%rbx)
jmp 0x66fd
xorl %ebx, %ebx
jmp 0x66fd
leaq 0x9f649(%rip), %rsi     # 0xa57fb
movl $0x28, %edi
movl $0x40, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f888(%rip), %rdi     # 0xa5a53
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9f882(%rip), %rdi     # 0xa5a5b
callq 0x54afc
movl %eax, 0x4(%rbx)
leaq 0x9f6fe(%rip), %rdi     # 0xa58e6
callq 0x54920
movl %eax, 0x8(%rbx)
leaq 0x9f871(%rip), %rdi     # 0xa5a68
callq 0x54bec
movl %eax, 0xc(%rbx)
leaq 0x9f5e5(%rip), %rdi     # 0xa57eb
callq 0x54afc
movl %eax, 0x10(%rbx)
leaq 0x9f862(%rip), %rdi     # 0xa5a77
callq 0x54c89
movq %rax, 0x18(%rbx)
leaq 0x9f85e(%rip), %rdi     # 0xa5a83
callq 0x54c89
movq %rax, 0x20(%rbx)
jmp 0x66fd
leaq 0x9f5c1(%rip), %rsi     # 0xa57fb
movl $0x20, %edi
movl $0x1f, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f72b(%rip), %rdi     # 0xa597e
callq 0x54920
movl %eax, (%rbx)
leaq 0x9f6c7(%rip), %rdi     # 0xa5928
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
leaq 0x9f682(%rip), %rdi     # 0xa58f4
callq 0x54a6f
testq %rax, %rax
je 0x6712
leaq 0x9f66d(%rip), %rdi     # 0xa58f4
callq 0x54a6f
movq %rax, %rdi
callq 0x4190
cmpq $0xc, %rax
jb 0x62a6
leaq 0x9f99c(%rip), %rdi     # 0xa5c3d
callq 0x4090
movq %rbx, %r14
addq $0x10, %r14
leaq 0x9f640(%rip), %rdi     # 0xa58f4
callq 0x54a6f
movq %r14, %rdi
movq %rax, %rsi
callq 0x4270
jmp 0x66fd
leaq 0x9f52b(%rip), %rsi     # 0xa57fb
movl $0x58, %edi
movl $0x2e, %edx
callq 0x3a0e1
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
jmp 0x6671
leaq 0x9f508(%rip), %rsi     # 0xa57fb
movl $0x8, %edi
movl $0xd, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f58f(%rip), %rdi     # 0xa589b
callq 0x549ba
movsd %xmm0, (%rbx)
jmp 0x66fd
leaq 0x9f4da(%rip), %rsi     # 0xa57fb
movl $0x18, %edi
movl $0x10, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f592(%rip), %rdi     # 0xa58cc
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
leaq 0x9f58d(%rip), %rdi     # 0xa58d8
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
leaq 0x9f58a(%rip), %rdi     # 0xa58e6
jmp 0x65da
leaq 0x9f493(%rip), %rsi     # 0xa57fb
movl $0x8, %edi
movl $0xc, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f41e(%rip), %rdi     # 0xa579f
callq 0x54920
movl %eax, 0x4(%rbx)
leaq 0x9f346(%rip), %rdi     # 0xa56d6
jmp 0x65da
leaq 0x9f45f(%rip), %rsi     # 0xa57fb
movl $0x98, %edi
movl $0xd, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f4cc(%rip), %rdi     # 0xa5881
callq 0x54920
movl %eax, (%rbx)
leaq 0x9f413(%rip), %rdi     # 0xa57d6
callq 0x54afc
movl %eax, 0x8(%rbx)
leaq 0x9f4b9(%rip), %rdi     # 0xa588b
callq 0x54a6f
testq %rax, %rax
je 0x6420
leaq 0x9f4a8(%rip), %rdi     # 0xa588b
callq 0x54a6f
movq %rax, %rdi
callq 0x4190
cmpq $0x65, %rax
jb 0x6402
leaq 0x9f87d(%rip), %rdi     # 0xa5c7a
callq 0x4090
movq %rbx, %r14
addq $0x30, %r14
leaq 0x9f47b(%rip), %rdi     # 0xa588b
callq 0x54a6f
movq %r14, %rdi
movq %rax, %rsi
callq 0x4270
leaq 0x9f474(%rip), %rdi     # 0xa589b
callq 0x549ba
movsd %xmm0, 0x28(%rbx)
leaq 0x9f2fa(%rip), %rdi     # 0xa5732
callq 0x54afc
movl %eax, 0x14(%rbx)
leaq 0x9f3dc(%rip), %rdi     # 0xa5823
callq 0x54920
movl %eax, 0x4(%rbx)
leaq 0x9f458(%rip), %rdi     # 0xa58ae
callq 0x54bec
movl %eax, 0xc(%rbx)
leaq 0x9f455(%rip), %rdi     # 0xa58ba
jmp 0x64f3
leaq 0x9f38a(%rip), %rsi     # 0xa57fb
movl $0xc, %edi
movl $0xc, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f315(%rip), %rdi     # 0xa579f
callq 0x54920
movl %eax, 0x4(%rbx)
leaq 0x9f23d(%rip), %rdi     # 0xa56d6
callq 0x54920
movl %eax, (%rbx)
leaq 0x9f3cd(%rip), %rdi     # 0xa5874
callq 0x54920
movl %eax, 0x8(%rbx)
jmp 0x66fd
leaq 0x9f340(%rip), %rsi     # 0xa57fb
movl $0x18, %edi
movl $0x9, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f25e(%rip), %rdi     # 0xa5732
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9f29f(%rip), %rdi     # 0xa5781
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
leaq 0x9f1ee(%rip), %rdi     # 0xa56e1
callq 0x54afc
movl %eax, 0x10(%rbx)
jmp 0x66fd
leaq 0x9f2f4(%rip), %rsi     # 0xa57fb
movl $0x10, %edi
movl $0x24, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f467(%rip), %rdi     # 0xa5987
callq 0x549ba
movsd %xmm0, (%rbx)
leaq 0x9f46b(%rip), %rdi     # 0xa599b
callq 0x54920
movl %eax, 0x8(%rbx)
leaq 0x9f46b(%rip), %rdi     # 0xa59aa
callq 0x54920
movl %eax, 0xc(%rbx)
jmp 0x66fd
leaq 0x9f2a8(%rip), %rsi     # 0xa57fb
movl $0x28, %edi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f2d0(%rip), %rdi     # 0xa583c
callq 0x549ba
movsd %xmm0, (%rbx)
leaq 0x9f2c6(%rip), %rdi     # 0xa5842
callq 0x54afc
movl %eax, 0x8(%rbx)
leaq 0x9f2c2(%rip), %rdi     # 0xa584d
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
leaq 0x9f2ba(%rip), %rdi     # 0xa5856
callq 0x54920
movl %eax, 0x18(%rbx)
leaq 0x9f2b5(%rip), %rdi     # 0xa5860
callq 0x549ba
movsd %xmm0, 0x20(%rbx)
jmp 0x66fd
leaq 0x9f23a(%rip), %rsi     # 0xa57fb
movl $0x4, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f249(%rip), %rdi     # 0xa5823
callq 0x54920
movl %eax, (%rbx)
jmp 0x66fd
leaq 0x9f20e(%rip), %rsi     # 0xa57fb
movl $0x18, %edi
movl $0x2d, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x9f332(%rip), %rdi     # 0xa5938
callq 0x54afc
movl %eax, 0xc(%rbx)
leaq 0x9f401(%rip), %rdi     # 0xa5a16
callq 0x54afc
movl %eax, (%rbx)
leaq 0x9f1b3(%rip), %rdi     # 0xa57d6
callq 0x54afc
movl %eax, 0x4(%rbx)
leaq 0x9f196(%rip), %rdi     # 0xa57c8
callq 0x54920
movl %eax, 0x8(%rbx)
leaq 0x9f3de(%rip), %rdi     # 0xa5a1f
callq 0x549ba
movsd %xmm0, 0x10(%rbx)
jmp 0x66fd
leaq 0x9f1a4(%rip), %rsi     # 0xa57fb
movl $0x58, %edi
movl $0x2e, %edx
callq 0x3a0e1
movq %rax, %rbx
movq %rax, %rdi
movl $0x3, %esi
callq 0x9410f
jmp 0x66fd
movl $0x1, %r10d
subq $0x8, %rsp
leaq 0x20(%rsp), %r14
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movsd 0x8(%rsp), %xmm0
movl %r15d, %r8d
movq %r12, %r9
pushq %r10
pushq %rax
pushq $0x0
jmp 0x66e4
movl $0x1, %r10d
subq $0x8, %rsp
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movsd 0x8(%rsp), %xmm0
movl $0x1, %r8d
xorl %r9d, %r9d
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
pushq %r10
pushq %rax
pushq %r15
callq 0x445fb
addq $0x20, %rsp
movl $0x90, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, 0x10(%rbx)
jmp 0x66fd