// File: /workspace/github_c_makefile_star2_O1/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 0x9c85f(%rip), %rax     # 0xa23c4
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x9cc86(%rip), %rsi     # 0xa27fb
movl $0x60, %edi
movl $0x10, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9cd66(%rip), %rdi     # 0xa28f4
callq 0x5356b
testq %rax, %rax
je 0x5d3d
leaq 0x9cd51(%rip), %rdi     # 0xa28f4
callq 0x5356b
movq %rax, %rdi
callq 0x4190
cmpq $0xc, %rax
jb 0x5bc2
leaq 0x9d080(%rip), %rdi     # 0xa2c3d
callq 0x4090
leaq 0x9cd2b(%rip), %rdi     # 0xa28f4
callq 0x5356b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4270
jmp 0x5d40
leal -0x7d0(%r14), %eax
cmpl $0x10, %eax
ja 0x5ebe
leaq 0x9c873(%rip), %rcx     # 0xa2468
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9cbf6(%rip), %rsi     # 0xa27fb
movl $0x28, %edi
movl $0x25, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9cd1a(%rip), %rdi     # 0xa2938
callq 0x535f7
movl %eax, 0x1c(%rbx)
leaq 0x9cde9(%rip), %rdi     # 0xa2a16
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9cb9b(%rip), %rdi     # 0xa27d6
callq 0x535f7
movl %eax, 0x8(%rbx)
leaq 0x9cbe8(%rip), %rdi     # 0xa2832
callq 0x5341c
movl %eax, 0x18(%rbx)
leaq 0x9cad9(%rip), %rdi     # 0xa2732
callq 0x535f7
movl %eax, 0x4(%rbx)
leaq 0x9cb19(%rip), %rdi     # 0xa2781
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
leaq 0x9cda6(%rip), %rdi     # 0xa2a1f
jmp 0x65ab
leaq 0x9cb76(%rip), %rsi     # 0xa27fb
movl $0x10, %edi
movl $0x9, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9ca94(%rip), %rdi     # 0xa2732
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9cbbd(%rip), %rdi     # 0xa2869
callq 0x535f7
movl %eax, 0x4(%rbx)
leaq 0x9cac6(%rip), %rdi     # 0xa2781
jmp 0x5f5b
leaq 0x9cb34(%rip), %rsi     # 0xa27fb
movl $0x28, %edi
movl $0x25, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9cd36(%rip), %rdi     # 0xa2a16
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9cbf8(%rip), %rdi     # 0xa28e6
callq 0x5341c
movl %eax, 0x4(%rbx)
leaq 0x9cbdb(%rip), %rdi     # 0xa28d8
callq 0x534b6
movsd %xmm0, 0x8(%rbx)
leaq 0x9cbbe(%rip), %rdi     # 0xa28cc
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
leaq 0x9ccb1(%rip), %rdi     # 0xa29d0
callq 0x534b6
movsd %xmm0, 0x18(%rbx)
leaq 0x9ccfd(%rip), %rdi     # 0xa2a2d
callq 0x535f7
movl %eax, 0x20(%rbx)
jmp 0x66fd
movb $0x0, (%rbx)
leaq 0x9ca81(%rip), %rdi     # 0xa27c8
callq 0x5341c
movl %eax, 0x10(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x24(%rbx)
movl $0x1, 0xc(%rbx)
leaq 0x9cba3(%rip), %rdi     # 0xa2905
callq 0x536e7
movl %eax, 0x18(%rbx)
leaq 0x9cb03(%rip), %rdi     # 0xa2874
callq 0x5341c
movl %eax, 0x1c(%rbx)
leaq 0x9cb8e(%rip), %rdi     # 0xa290e
callq 0x536e7
movl %eax, 0x14(%rbx)
leaq 0x9cb89(%rip), %rdi     # 0xa2918
callq 0x536e7
movl %eax, 0x20(%rbx)
leaq 0x9cb8a(%rip), %rdi     # 0xa2928
callq 0x534b6
movsd %xmm0, 0x30(%rbx)
leaq 0x9cb89(%rip), %rdi     # 0xa2938
callq 0x535f7
movl %eax, 0x3c(%rbx)
movl %ebp, 0x28(%rbx)
leaq 0x9ca15(%rip), %rdi     # 0xa27d6
callq 0x535f7
movl %eax, 0x38(%rbx)
leaq 0x9ca62(%rip), %rdi     # 0xa2832
callq 0x5341c
movl %eax, 0x40(%rbx)
leaq 0x9cb68(%rip), %rdi     # 0xa2947
callq 0x535f7
movl %eax, 0x2c(%rbx)
leaq 0x9cb6f(%rip), %rdi     # 0xa295d
callq 0x534b6
movsd %xmm0, 0x48(%rbx)
leaq 0x9ca9c(%rip), %rdi     # 0xa289b
callq 0x534b6
movsd %xmm0, 0x50(%rbx)
leaq 0x9cb5b(%rip), %rdi     # 0xa296b
callq 0x536e7
movl %eax, 0x58(%rbx)
jmp 0x5ebe
leaq 0x9c9d7(%rip), %rsi     # 0xa27fb
movl $0x40, %edi
movl $0x2d, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c8f5(%rip), %rdi     # 0xa2732
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9c936(%rip), %rdi     # 0xa2781
callq 0x534b6
movsd %xmm0, 0x8(%rbx)
movl $0x1, 0x2c(%rbx)
leaq 0x9cad5(%rip), %rdi     # 0xa2938
callq 0x535f7
movl %eax, 0x28(%rbx)
leaq 0x9c964(%rip), %rdi     # 0xa27d6
callq 0x535f7
movl %eax, 0x18(%rbx)
leaq 0x9ca1a(%rip), %rdi     # 0xa289b
callq 0x534b6
movsd %xmm0, 0x20(%rbx)
leaq 0x9cacb(%rip), %rdi     # 0xa295d
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
leaq 0x9cb99(%rip), %rdi     # 0xa2a3c
callq 0x534b6
movsd %xmm0, 0x30(%rbx)
leaq 0x9cb8e(%rip), %rdi     # 0xa2a42
callq 0x534b6
movsd %xmm0, 0x38(%rbx)
addl $0xfffffc12, %r14d      # imm = 0xFFFFFC12
cmpl $0x9, %r14d
ja 0x61a4
leaq 0x9c5d6(%rip), %rax     # 0xa24ac
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x1, 0x28(%rbx)
jmp 0x6171
leaq 0x9c909(%rip), %rsi     # 0xa27fb
movl $0x30, %edi
movl $0x2e, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c8a0(%rip), %rdi     # 0xa27ab
callq 0x534b6
movsd %xmm0, 0x20(%rbx)
leaq 0x9cb2c(%rip), %rdi     # 0xa2a48
callq 0x534b6
movsd %xmm0, 0x28(%rbx)
leaq 0x9c915(%rip), %rdi     # 0xa2842
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9c912(%rip), %rdi     # 0xa284d
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
leaq 0x9c90a(%rip), %rdi     # 0xa2856
callq 0x5341c
movl %eax, 0x4(%rbx)
leaq 0x9c905(%rip), %rdi     # 0xa2860
callq 0x534b6
movsd %xmm0, 0x8(%rbx)
jmp 0x66fd
leaq 0x9c88a(%rip), %rsi     # 0xa27fb
movl $0x90, %edi
movl $0x22, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9ca35(%rip), %rdi     # 0xa29bf
callq 0x536e7
movl %eax, %ebp
leaq 0x9ca33(%rip), %rdi     # 0xa29cb
callq 0x534b6
movsd %xmm0, (%rsp)
leaq 0x9ca2d(%rip), %rdi     # 0xa29d6
callq 0x5341c
movl %eax, %r15d
leaq 0x9c9fb(%rip), %rdi     # 0xa29b3
callq 0x53784
movq %rax, %r12
leaq 0x9ca1c(%rip), %rdi     # 0xa29e3
callq 0x5341c
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 0x9c7f7(%rip), %rsi     # 0xa27fb
movl $0x4, %edi
movl $0x6, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c815(%rip), %rdi     # 0xa2832
jmp 0x65da
leaq 0x9c7d2(%rip), %rsi     # 0xa27fb
movl $0x90, %edi
movl $0x26, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c97d(%rip), %rdi     # 0xa29bf
callq 0x536e7
movl %eax, %ebp
leaq 0x9c97b(%rip), %rdi     # 0xa29cb
callq 0x534b6
movsd %xmm0, (%rsp)
leaq 0x9c98c(%rip), %rdi     # 0xa29ed
callq 0x5341c
movl %eax, %r15d
leaq 0x9c988(%rip), %rdi     # 0xa29f8
callq 0x534b6
movsd %xmm0, 0x10(%rsp)
leaq 0x9c985(%rip), %rdi     # 0xa2a07
callq 0x534b6
movsd %xmm0, 0x8(%rsp)
leaq 0x9c94f(%rip), %rdi     # 0xa29e3
callq 0x5341c
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 0x9c72a(%rip), %rsi     # 0xa27fb
movl $0x40, %edi
movl $0x22, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0xcc786(%rip), %rax     # 0xd2870
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 0x9c8a9(%rip), %rdi     # 0xa29b3
callq 0x53784
movl (%rax), %eax
movl %eax, 0x4(%rbx)
leaq 0x9c7cb(%rip), %rdi     # 0xa28e6
callq 0x5341c
movl %eax, 0xc(%rbx)
leaq 0x9c8a6(%rip), %rdi     # 0xa29d0
callq 0x534b6
movsd %xmm0, 0x38(%rbx)
leaq 0x9c79d(%rip), %rdi     # 0xa28d8
callq 0x534b6
movsd %xmm0, 0x28(%rbx)
movsd %xmm0, 0x18(%rbx)
leaq 0x9c77b(%rip), %rdi     # 0xa28cc
callq 0x534b6
movsd %xmm0, 0x30(%rbx)
movabsq $0x3f847ae147ae147b, %rax # imm = 0x3F847AE147AE147B
jmp 0x622a
movl $0x2, 0x28(%rbx)
leaq 0x9c7cf(%rip), %rdi     # 0xa2947
callq 0x535f7
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 0x9c649(%rip), %rsi     # 0xa27fb
movl $0x28, %edi
movl $0x40, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c888(%rip), %rdi     # 0xa2a53
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9c882(%rip), %rdi     # 0xa2a5b
callq 0x535f7
movl %eax, 0x4(%rbx)
leaq 0x9c6fe(%rip), %rdi     # 0xa28e6
callq 0x5341c
movl %eax, 0x8(%rbx)
leaq 0x9c871(%rip), %rdi     # 0xa2a68
callq 0x536e7
movl %eax, 0xc(%rbx)
leaq 0x9c5e5(%rip), %rdi     # 0xa27eb
callq 0x535f7
movl %eax, 0x10(%rbx)
leaq 0x9c862(%rip), %rdi     # 0xa2a77
callq 0x53784
movq %rax, 0x18(%rbx)
leaq 0x9c85e(%rip), %rdi     # 0xa2a83
callq 0x53784
movq %rax, 0x20(%rbx)
jmp 0x66fd
leaq 0x9c5c1(%rip), %rsi     # 0xa27fb
movl $0x20, %edi
movl $0x1f, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c72b(%rip), %rdi     # 0xa297e
callq 0x5341c
movl %eax, (%rbx)
leaq 0x9c6c7(%rip), %rdi     # 0xa2928
callq 0x534b6
movsd %xmm0, 0x8(%rbx)
leaq 0x9c682(%rip), %rdi     # 0xa28f4
callq 0x5356b
testq %rax, %rax
je 0x6712
leaq 0x9c66d(%rip), %rdi     # 0xa28f4
callq 0x5356b
movq %rax, %rdi
callq 0x4190
cmpq $0xc, %rax
jb 0x62a6
leaq 0x9c99c(%rip), %rdi     # 0xa2c3d
callq 0x4090
movq %rbx, %r14
addq $0x10, %r14
leaq 0x9c640(%rip), %rdi     # 0xa28f4
callq 0x5356b
movq %r14, %rdi
movq %rax, %rsi
callq 0x4270
jmp 0x66fd
leaq 0x9c52b(%rip), %rsi     # 0xa27fb
movl $0x58, %edi
movl $0x2e, %edx
callq 0x390f5
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
jmp 0x6671
leaq 0x9c508(%rip), %rsi     # 0xa27fb
movl $0x8, %edi
movl $0xd, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c58f(%rip), %rdi     # 0xa289b
callq 0x534b6
movsd %xmm0, (%rbx)
jmp 0x66fd
leaq 0x9c4da(%rip), %rsi     # 0xa27fb
movl $0x18, %edi
movl $0x10, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c592(%rip), %rdi     # 0xa28cc
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
leaq 0x9c58d(%rip), %rdi     # 0xa28d8
callq 0x534b6
movsd %xmm0, 0x8(%rbx)
leaq 0x9c58a(%rip), %rdi     # 0xa28e6
jmp 0x65da
leaq 0x9c493(%rip), %rsi     # 0xa27fb
movl $0x8, %edi
movl $0xc, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c41e(%rip), %rdi     # 0xa279f
callq 0x5341c
movl %eax, 0x4(%rbx)
leaq 0x9c346(%rip), %rdi     # 0xa26d6
jmp 0x65da
leaq 0x9c45f(%rip), %rsi     # 0xa27fb
movl $0x98, %edi
movl $0xd, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c4cc(%rip), %rdi     # 0xa2881
callq 0x5341c
movl %eax, (%rbx)
leaq 0x9c413(%rip), %rdi     # 0xa27d6
callq 0x535f7
movl %eax, 0x8(%rbx)
leaq 0x9c4b9(%rip), %rdi     # 0xa288b
callq 0x5356b
testq %rax, %rax
je 0x6420
leaq 0x9c4a8(%rip), %rdi     # 0xa288b
callq 0x5356b
movq %rax, %rdi
callq 0x4190
cmpq $0x65, %rax
jb 0x6402
leaq 0x9c87d(%rip), %rdi     # 0xa2c7a
callq 0x4090
movq %rbx, %r14
addq $0x30, %r14
leaq 0x9c47b(%rip), %rdi     # 0xa288b
callq 0x5356b
movq %r14, %rdi
movq %rax, %rsi
callq 0x4270
leaq 0x9c474(%rip), %rdi     # 0xa289b
callq 0x534b6
movsd %xmm0, 0x28(%rbx)
leaq 0x9c2fa(%rip), %rdi     # 0xa2732
callq 0x535f7
movl %eax, 0x14(%rbx)
leaq 0x9c3dc(%rip), %rdi     # 0xa2823
callq 0x5341c
movl %eax, 0x4(%rbx)
leaq 0x9c458(%rip), %rdi     # 0xa28ae
callq 0x536e7
movl %eax, 0xc(%rbx)
leaq 0x9c455(%rip), %rdi     # 0xa28ba
jmp 0x64f3
leaq 0x9c38a(%rip), %rsi     # 0xa27fb
movl $0xc, %edi
movl $0xc, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c315(%rip), %rdi     # 0xa279f
callq 0x5341c
movl %eax, 0x4(%rbx)
leaq 0x9c23d(%rip), %rdi     # 0xa26d6
callq 0x5341c
movl %eax, (%rbx)
leaq 0x9c3cd(%rip), %rdi     # 0xa2874
callq 0x5341c
movl %eax, 0x8(%rbx)
jmp 0x66fd
leaq 0x9c340(%rip), %rsi     # 0xa27fb
movl $0x18, %edi
movl $0x9, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c25e(%rip), %rdi     # 0xa2732
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9c29f(%rip), %rdi     # 0xa2781
callq 0x534b6
movsd %xmm0, 0x8(%rbx)
leaq 0x9c1ee(%rip), %rdi     # 0xa26e1
callq 0x535f7
movl %eax, 0x10(%rbx)
jmp 0x66fd
leaq 0x9c2f4(%rip), %rsi     # 0xa27fb
movl $0x10, %edi
movl $0x24, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c467(%rip), %rdi     # 0xa2987
callq 0x534b6
movsd %xmm0, (%rbx)
leaq 0x9c46b(%rip), %rdi     # 0xa299b
callq 0x5341c
movl %eax, 0x8(%rbx)
leaq 0x9c46b(%rip), %rdi     # 0xa29aa
callq 0x5341c
movl %eax, 0xc(%rbx)
jmp 0x66fd
leaq 0x9c2a8(%rip), %rsi     # 0xa27fb
movl $0x28, %edi
movl $0x6, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c2d0(%rip), %rdi     # 0xa283c
callq 0x534b6
movsd %xmm0, (%rbx)
leaq 0x9c2c6(%rip), %rdi     # 0xa2842
callq 0x535f7
movl %eax, 0x8(%rbx)
leaq 0x9c2c2(%rip), %rdi     # 0xa284d
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
leaq 0x9c2ba(%rip), %rdi     # 0xa2856
callq 0x5341c
movl %eax, 0x18(%rbx)
leaq 0x9c2b5(%rip), %rdi     # 0xa2860
callq 0x534b6
movsd %xmm0, 0x20(%rbx)
jmp 0x66fd
leaq 0x9c23a(%rip), %rsi     # 0xa27fb
movl $0x4, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c249(%rip), %rdi     # 0xa2823
callq 0x5341c
movl %eax, (%rbx)
jmp 0x66fd
leaq 0x9c20e(%rip), %rsi     # 0xa27fb
movl $0x18, %edi
movl $0x2d, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x9c332(%rip), %rdi     # 0xa2938
callq 0x535f7
movl %eax, 0xc(%rbx)
leaq 0x9c401(%rip), %rdi     # 0xa2a16
callq 0x535f7
movl %eax, (%rbx)
leaq 0x9c1b3(%rip), %rdi     # 0xa27d6
callq 0x535f7
movl %eax, 0x4(%rbx)
leaq 0x9c196(%rip), %rdi     # 0xa27c8
callq 0x5341c
movl %eax, 0x8(%rbx)
leaq 0x9c3de(%rip), %rdi     # 0xa2a1f
callq 0x534b6
movsd %xmm0, 0x10(%rbx)
jmp 0x66fd
leaq 0x9c1a4(%rip), %rsi     # 0xa27fb
movl $0x58, %edi
movl $0x2e, %edx
callq 0x390f5
movq %rax, %rbx
movq %rax, %rdi
movl $0x3, %esi
callq 0x916af
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 0x43275
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