LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/decisiontree.c
// Function: leaf_distribution
void leaf_distribution(Decisionnodeptr rootnode, int* counts)
{
 /*!Last Changed 01.10.2006 added decisiontree with single leaf node*/
 /*!Last Changed 13.07.2006*/
 int level, index;
 if (rootnode->featureno == LEAF_NODE)
  {
   level = level_of_node(rootnode);
   if (level == 0)
     index = 1;
   else
     if (rootnode->parent->left == rootnode) 
       if (rootnode->parent->right->featureno == LEAF_NODE)
         index = 2 * level;
       else
         index = 2 * level + 1;
     else
       if (rootnode->parent->left->featureno == LEAF_NODE)
         index = 2 * level;
       else
         index = 2 * level + 1;
   counts[index - 1]++;
  }
 else
  {
   leaf_distribution(rootnode->left, counts);
   leaf_distribution(rootnode->right, counts);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, 0x30(%rdi)
je 0x1e5f2
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1e5cc
movq 0x8(%r14), %r14
cmpl $-0x1, 0x30(%r14)
jne 0x1e5dc
movl $0x1, %ecx
movl $0x2, %eax
movq %r14, %rdx
movq 0x18(%rdx), %rdx
decl %ecx
addl $-0x2, %eax
testq %rdx, %rdx
jne 0x1e5ff
testl %ecx, %ecx
je 0x1e62e
movq 0x18(%r14), %rcx
movq (%rcx), %rdx
cmpq %r14, %rdx
jne 0x1e621
movq 0x8(%rcx), %rdx
xorl %ecx, %ecx
cmpl $-0x1, 0x30(%rdx)
setne %cl
subl %eax, %ecx
jmp 0x1e633
movl $0x1, %ecx
incl -0x4(%rbx,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: dimension_reduction_pca
Instanceptr dimension_reduction_pca(Datasetptr d, Instanceptr traindata, void* parameters, Datasetptr* new_dataset, char* new_dataset_name)
{
 /*!Last Changed 16.01.2008*/
 int howmany = 0;
 matrix eigenvectors, cov;
 double *eigenvalues;
 Instance mean;
 Pca_parameterptr ppca = (Pca_parameterptr) parameters;
 Instanceptr newlist;
 mean = find_mean(traindata);
 cov = covariance(traindata, mean);
 safe_free(mean.values);
 switch (ppca->reduction_type)
  {
   case REDUCTION_TYPE_FEATURE :eigenvalues = find_eigenvalues_eigenvectors_symmetric(&eigenvectors, cov);
                                if (ppca->featurecount <= d->multifeaturecount - 1)
                                  howmany = ppca->featurecount;
                                break;
   case REDUCTION_TYPE_VARIANCE:eigenvalues = find_eigenvalues_eigenvectors(&eigenvectors, cov, &howmany, ppca->variance_explained);
                                break;
  }
 safe_free(eigenvalues);
 newlist = reduce_dimension_of_instancelist(traindata, howmany, eigenvectors);
 *new_dataset = dimension_reduced_dataset(d, howmany + 1, newlist, new_dataset_name);
 matrix_free(eigenvectors);
 matrix_free(cov);
 return newlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movl $0x0, 0x34(%rsp)
leaq 0x78(%rsp), %r14
movq %r14, %rdi
callq 0x1247b
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbp, %rdi
callq 0x11398
movq %rax, %rbx
movq %rdx, %r15
movq (%r14), %rdi
callq 0x3a180
cmpl $0x0, 0x10(%r13)
je 0x1e6d2
movsd 0x8(%r13), %xmm0
leaq 0x48(%rsp), %rdi
leaq 0x34(%rsp), %rcx
movq %rbx, %rsi
movq %r15, %rdx
callq 0x42921
movq %r15, %r14
jmp 0x1e6f7
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x428e9
movl (%r13), %ecx
cmpl 0x1c0(%r12), %ecx
movq %r15, %r14
jge 0x1e6f7
movl %ecx, 0x34(%rsp)
movq 0x38(%rsp), %r15
movq %r12, 0x68(%rsp)
movq %rax, %rdi
callq 0x3a180
movl 0x34(%rsp), %esi
testq %rbp, %rbp
je 0x1e77e
movq %r14, 0x58(%rsp)
movq %rbx, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x50(%rsp), %r12
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %rbp, %rdi
movl %esi, %r15d
movq 0x70(%rsp), %rdx
movq %r12, %rcx
callq 0x1f1cb
movq %rax, %r13
testq %r14, %r14
je 0x1e752
movq %rax, 0x10(%rbx)
movq %r14, %r13
movq 0x10(%rbp), %rbp
movq %r13, %r14
movq %rax, %rbx
testq %rbp, %rbp
movl %r15d, %esi
jne 0x1e730
movl 0x34(%rsp), %esi
movq 0x38(%rsp), %r15
movq 0x40(%rsp), %rcx
movq 0x60(%rsp), %rbx
movq 0x58(%rsp), %r14
jmp 0x1e786
xorl %r13d, %r13d
movq 0x40(%rsp), %rcx
incl %esi
movq 0x68(%rsp), %rdi
movq %r13, %rdx
callq 0x153ec
movq %rax, (%r15)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x3ed51
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ed51
movq %r13, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: dimension_reduction_mds
Instanceptr dimension_reduction_mds(Datasetptr d, Instanceptr traindata, void* parameters, Datasetptr* new_dataset, char* new_dataset_name)
{
 /*!Last Changed 17.01.2008*/
 int howmany;
 matrix eigenvectors, distancematrix, b;
 double *eigenvalues;
 Pca_parameterptr ppca = (Pca_parameterptr) parameters;
 Instanceptr newlist;
 distancematrix = distance_matrix(traindata);
 b = multi_dimensional_scaling(distancematrix);
 matrix_free(distancematrix);
 switch (ppca->reduction_type)
  {
   case REDUCTION_TYPE_FEATURE :eigenvalues = find_eigenvalues_eigenvectors_symmetric(&eigenvectors, b);
                                howmany = ppca->featurecount;
                                break;
   case REDUCTION_TYPE_VARIANCE:eigenvalues = find_eigenvalues_eigenvectors(&eigenvectors, b, &howmany, ppca->variance_explained);
                                break;
  }
 matrix_free(b);
 newlist = reduce_dimension_of_instancelist_mds(traindata, howmany, eigenvectors, eigenvalues);
 *new_dataset = dimension_reduced_dataset(d, howmany + 1, newlist, new_dataset_name);
 return newlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x10af1
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x1f636
movq %rax, %r13
movq %rdx, %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ed51
movl 0x10(%rbx), %eax
cmpl $0x1, %eax
je 0x1ea11
testl %eax, %eax
jne 0x1ea2e
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x428e9
movq %rax, %r14
movl (%rbx), %eax
movl %eax, 0xc(%rsp)
jmp 0x1ea2e
movsd 0x8(%rbx), %xmm0
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rcx
movq %r13, %rsi
movq %rbp, %rdx
callq 0x42921
movq %rax, %r14
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3ed51
movl 0xc(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %r12, %rdi
movq %r14, %r8
callq 0x1f4ca
movq %rax, %rbx
movl 0xc(%rsp), %esi
incl %esi
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
callq 0x153ec
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: dimension_reduction_lle
Instanceptr dimension_reduction_lle(Datasetptr d, Instanceptr traindata, void* parameters, Datasetptr* new_dataset, char* new_dataset_name)
{
 /*!Last Changed 19.01.2008*/
 int howmany;
 matrix eigenvectors, neighborhood, w, M;
 double *eigenvalues;
 Isomap_parameterptr pisomap = (Isomap_parameterptr) parameters;
 Instanceptr newlist; 
 switch (pisomap->neighborhood_type)
  {
   case NEIGHBORHOOD_TYPE_EPSILON:neighborhood = determine_neighborhood_epsilon(traindata, pisomap->epsilon);
                                  break;
   case       NEIGHBORHOOD_TYPE_K:neighborhood = determine_neighborhood_k(traindata, pisomap->k);
                                  break;
  }
 w = local_contributions_of_neighbors(d, traindata, neighborhood);
 matrix_free(neighborhood);
 M = calculate_m_for_lle(w);
 matrix_free(w);
 switch (pisomap->ppca.reduction_type)
  {
   case REDUCTION_TYPE_FEATURE :eigenvalues = find_eigenvalues_eigenvectors_symmetric(&eigenvectors, M);
                                howmany = pisomap->ppca.featurecount;
                                break;
   case REDUCTION_TYPE_VARIANCE:eigenvalues = find_eigenvalues_eigenvectors(&eigenvectors, M, &howmany, 1 - pisomap->ppca.variance_explained);
                                break;
  }
 matrix_free(M);
 newlist = reduce_dimension_of_instancelist_lle(traindata, howmany, eigenvectors, eigenvalues);
 *new_dataset = dimension_reduced_dataset(d, howmany + 1, newlist, new_dataset_name);
 return newlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movl 0x24(%rdx), %eax
cmpl $0x1, %eax
movq %rcx, 0x8(%rsp)
movq %r8, 0x20(%rsp)
je 0x1ec1c
testl %eax, %eax
jne 0x1ec30
movsd 0x18(%r13), %xmm0
movq %r12, %rdi
callq 0x1f11f
jmp 0x1ec28
movl 0x20(%r13), %esi
movq %r12, %rdi
callq 0x1ef19
movq %rax, %rbx
movq %rdx, %r14
jmp 0x1ec30
movq %r15, 0x18(%rsp)
movq %r15, %rdi
movq %r12, 0x10(%rsp)
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1f8ee
movq %rax, %r15
movq %rdx, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ed51
movq %r15, %rdi
movq %r12, %rsi
callq 0x1fa1f
movq %rax, %rbp
movq %rdx, %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed51
movl 0x10(%r13), %eax
cmpl $0x1, %eax
je 0x1eca7
testl %eax, %eax
movq 0x8(%rsp), %r15
jne 0x1ecd2
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x428e9
movq %rax, %r14
movl (%r13), %eax
movl %eax, 0x4(%rsp)
jmp 0x1ecd2
movsd 0x86871(%rip), %xmm0    # 0xa5520
subsd 0x8(%r13), %xmm0
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rcx
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x42921
movq %rax, %r14
movq 0x8(%rsp), %r15
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x3ed51
movl 0x4(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %r14, %r8
callq 0x1f59b
movq %rax, %rbx
movl 0x4(%rsp), %esi
incl %esi
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
callq 0x153ec
movq %rax, (%r15)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: prepare_dimension_reduction_algorithm_parameters
void* prepare_dimension_reduction_algorithm_parameters(DIMENSION_REDUCTION_NAME algorithm)
{
 /*!Last Changed 12.01.2008*/
 Pca_parameterptr ppca;
 Isomap_parameterptr pisomap;
 switch (algorithm)
  {
   case PCA   :
   case LDA   :
   case MDS   :ppca = safemalloc(sizeof(Pca_parameter), "prepare_dimension_reduction_algorithm_parameters", 4);
               ppca->featurecount = get_parameter_i("reducedfeaturecount");
               ppca->variance_explained = get_parameter_f("variance_explained");
               ppca->reduction_type = get_parameter_l("dimensionreducetype");
               return ppca;
               break;
   case ISOMAP:
   case    LLE:pisomap = safemalloc(sizeof(Isomap_parameter), "prepare_dimension_reduction_algorithm_parameters", 12);
               pisomap->ppca.featurecount = get_parameter_i("reducedfeaturecount");
               pisomap->ppca.variance_explained = get_parameter_f("variance_explained");
               pisomap->ppca.reduction_type = get_parameter_l("dimensionreducetype");
               pisomap->epsilon = get_parameter_f("epsilon");
               pisomap->k = get_parameter_i("nearcount");
               pisomap->neighborhood_type = get_parameter_l("neighborhoodtype");
               return pisomap;
               break;
  }
 return NULL;
}

// Assembly:
pushq %rbx
cmpl $0x3, %edi
jae 0x1ed7a
leaq 0x88c5e(%rip), %rsi     # 0xa7993
movl $0x18, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x88c76(%rip), %rdi     # 0xa79c4
callq 0x54920
movl %eax, (%rbx)
leaq 0x86b3f(%rip), %rdi     # 0xa589b
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
leaq 0x88c6b(%rip), %rdi     # 0xa79d8
callq 0x54afc
movl %eax, 0x10(%rbx)
jmp 0x1edfc
addl $-0x3, %edi
cmpl $0x2, %edi
jae 0x1edfa
leaq 0x88c0a(%rip), %rsi     # 0xa7993
movl $0x28, %edi
movl $0xc, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x88c22(%rip), %rdi     # 0xa79c4
callq 0x54920
movl %eax, (%rbx)
leaq 0x86aeb(%rip), %rdi     # 0xa589b
callq 0x549ba
movsd %xmm0, 0x8(%rbx)
leaq 0x88c17(%rip), %rdi     # 0xa79d8
callq 0x54afc
movl %eax, 0x10(%rbx)
leaq 0x86c7b(%rip), %rdi     # 0xa5a4b
callq 0x549ba
movsd %xmm0, 0x18(%rbx)
leaq 0x86a51(%rip), %rdi     # 0xa5832
callq 0x54920
movl %eax, 0x20(%rbx)
leaq 0x88bfc(%rip), %rdi     # 0xa79ec
callq 0x54afc
movl %eax, 0x24(%rbx)
jmp 0x1edfc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: minimum_k_neighborhood
int minimum_k_neighborhood(Instanceptr inst)
{
 /*!Last Changed 08.04.2008 rewritten*/
 /*!Last Changed 04.04.2008*/
 int k, size = data_size(inst), upper, lower, mean;
 matrix graph;
 for (k = 1; k < size; k *= 2)
  {
   graph = determine_neighborhood_k(inst, k);
   if (is_graph_connected(graph))
    {
     matrix_free(graph);
     break;
    }
   matrix_free(graph);
  }
 if (k > size)
   upper = size;
 else
   upper = k;
 lower = k / 2;
 mean = (upper + lower) / 2;
 while (mean != lower)
  {
   graph = determine_neighborhood_k(inst, mean);
   if (is_graph_connected(graph))
     upper = mean;
   else
     lower = mean;
   mean = (upper + lower) / 2;     
   matrix_free(graph);
  }
 return upper;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
callq 0x30309
movl %eax, %r14d
movl $0x1, %ebp
cmpl $0x2, %eax
jl 0x1eea0
movq (%rsp), %rdi
movl %ebp, %esi
callq 0x1ef19
movq %rax, %r15
movq %rdx, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0x1b282
movl %eax, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed51
testl %r13d, %r13d
jne 0x1eea0
addl %ebp, %ebp
cmpl %r14d, %ebp
jl 0x1ee6a
cmpl %r14d, %ebp
cmovll %ebp, %r14d
movl %ebp, %r13d
shrl $0x1f, %r13d
addl %ebp, %r13d
sarl %r13d
leal (%r14,%r13), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
cmpl %r13d, %ebp
je 0x1ef07
movq (%rsp), %rdi
movl %ebp, %esi
callq 0x1ef19
movq %rax, %r15
movq %rdx, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0x1b282
testl %eax, %eax
jne 0x1eeec
movl %ebp, %r13d
movl %r14d, %ebp
movl %ebp, %r14d
leal (%r14,%r13), %ebx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed51
movl %ebx, %ebp
shrl $0x1f, %ebp
addl %ebx, %ebp
jmp 0x1eebf
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: determine_neighborhood_k
matrix determine_neighborhood_k(Instanceptr data, int k)
{
 /*!Last Changed 08.04.2008*/
 /*!Last Changed 19.01.2008*/
 int i, j, size;
 double threshold;
 Instanceptr temp1, temp2;
 matrix result;
 size = data_size(data);
 result = matrix_alloc(size, size);
 for (i = 0, temp1 = data; i < size; i++, temp1 = temp1->next)
  {
   threshold = find_k_nearest_neighbor_distance(data, temp1, k);  
   for (j = 0, temp2 = data; j < size; j++, temp2 = temp2->next)
     if (i != j && distance_between_instances(temp1, temp2) < threshold + DBL_DELTA)
       result.values[i][j] = 1;
     else
       result.values[i][j] = 0;
  }
 for (i = 0; i < size; i++)
   for (j = i + 1; j < size; j++)
     if (result.values[i][j] != result.values[j][i])
       result.values[i][j] = result.values[j][i] = 1;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r15
callq 0x30309
movl %eax, %ebx
movl %eax, %edi
movl %eax, %esi
callq 0x3d79d
movq %rdx, %r14
testl %ebx, %ebx
jle 0x1f040
movq %rax, 0x10(%rsp)
movl %ebx, 0x8(%rsp)
movl %ebx, %r12d
xorl %ebp, %ebp
movq %r15, %r13
movq %r15, 0x18(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movl 0xc(%rsp), %edx
callq 0x3188e
addsd 0x86e62(%rip), %xmm0    # 0xa5dd8
movsd %xmm0, 0x20(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %rbp
jne 0x1ef89
movq (%r14,%rbp,8), %rax
jmp 0x1efae
movq %r13, %rdi
movq %r15, %rsi
callq 0x2fe29
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq (%r14,%rbp,8), %rax
jbe 0x1efae
movsd 0x86574(%rip), %xmm0    # 0xa5520
jmp 0x1efb2
xorpd %xmm0, %xmm0
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r15), %r15
cmpq %rbx, %r12
jne 0x1ef7e
incq %rbp
movq 0x10(%r13), %r13
cmpq %r12, %rbp
movq 0x18(%rsp), %r15
jne 0x1ef5f
cmpl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
jle 0x1f040
xorl %ebx, %ebx
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %r12, %rdx
movq %r14, %rsi
xorl %edi, %edi
movq %rdi, %r8
incq %rdi
cmpq %r12, %rdi
jae 0x1f030
movq (%r14,%r8,8), %r9
addq %rbx, %r9
movl $0x1, %r10d
movsd (%r9,%r10,8), %xmm0
movq (%rsi,%r10,8), %r11
ucomisd (%r11,%r8,8), %xmm0
jne 0x1f020
jnp 0x1f028
movq %rcx, (%r11,%r8,8)
movq %rcx, (%r9,%r10,8)
incq %r10
cmpq %r10, %rdx
jne 0x1f00c
addq $0x8, %rsi
addq $0x8, %rbx
decq %rdx
cmpq %r12, %rdi
jne 0x1eff4
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: minimum_epsilon_neighborhood
double minimum_epsilon_neighborhood(Instanceptr inst)
{
 /*!Last Changed 04.04.2008*/
 int i; 
 double epsilonmin = 0, epsilonmax, epsilonmean, epsilon;
 matrix graph, distancematrix = distance_matrix(inst);
 epsilonmax = matrix_max(distancematrix);
 matrix_free(distancematrix);
 epsilonmean = (epsilonmin + epsilonmax) / 2;
 epsilon = epsilonmax;
 for (i = 0; i < 30; i++)
  {
   graph = determine_neighborhood_epsilon(inst, epsilonmean);
   if (is_graph_connected(graph))
    {
     epsilon = epsilonmean;
     epsilonmax = epsilonmean;
    }
   else
     epsilonmin = epsilonmean;
   epsilonmean = (epsilonmax + epsilonmin) / 2;
   matrix_free(graph);
  }
 return epsilon;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x10af1
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x400d7
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ed51
xorpd %xmm2, %xmm2
movsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
movsd %xmm1, 0x10(%rsp)
addsd %xmm2, %xmm0
movl $0x1e, %ebp
mulsd 0x86c6f(%rip), %xmm0    # 0xa5d18
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1f11f
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x1b282
testl %eax, %eax
je 0x1f0df
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm1
jmp 0x1f0ea
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ed51
movsd 0x8(%rsp), %xmm0
decl %ebp
jne 0x1f0a1
movsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: determine_neighborhood_epsilon
matrix determine_neighborhood_epsilon(Instanceptr data, double epsilon)
{
 /*!Last Changed 19.01.2008*/
 int i, j, size;
 Instanceptr temp1, temp2;
 matrix result;
 size = data_size(data);
 result = matrix_alloc(size, size);
 for (i = 0, temp1 = data; i < size; i++, temp1 = temp1->next)
   for (j = 0, temp2 = data; j < size; j++, temp2 = temp2->next)
     if (i != j && distance_between_instances(temp1, temp2) < epsilon)
       result.values[i][j] = 1;
     else
       result.values[i][j] = 0;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rdi, (%rsp)
callq 0x30309
movl %eax, %ebp
movl %eax, %edi
movl %eax, %esi
callq 0x3d79d
movq %rax, 0x8(%rsp)
movq %rdx, %r15
testl %ebp, %ebp
jle 0x1f1b4
movl %ebp, %ebp
xorl %r14d, %r14d
movq (%rsp), %r12
xorl %ebx, %ebx
movq (%rsp), %r13
cmpq %rbx, %r14
jne 0x1f16d
movq (%r15,%r14,8), %rax
jmp 0x1f192
movq %r12, %rdi
movq %r13, %rsi
callq 0x2fe29
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq (%r15,%r14,8), %rax
jbe 0x1f192
movsd 0x86390(%rip), %xmm0    # 0xa5520
jmp 0x1f196
xorpd %xmm0, %xmm0
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r13), %r13
cmpq %rbx, %rbp
jne 0x1f162
incq %r14
movq 0x10(%r12), %r12
cmpq %rbp, %r14
jne 0x1f15c
movq 0x8(%rsp), %rax
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: reduce_dimension_of_instance
Instanceptr reduce_dimension_of_instance(Instanceptr inst, int howmany, matrix eigenvectors)
{
 /*!Last Changed 12.01.2008*/
 Instanceptr newinst;
 double sum;
 int i, j;
 newinst = empty_instance(howmany + 1);
 for (i = 0; i < howmany; i++)
  {
   sum = 0.0;
   for (j = 0; j < eigenvectors.row; j++)
     sum += eigenvectors.values[j][i] * real_feature(inst, j);
   newinst->values[i].floatvalue = sum;
  }
 newinst->values[howmany].stringindex = give_classno(inst);
 return newinst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r12
leal 0x1(%rbx), %edi
callq 0x15391
movq %rax, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
testl %ebx, %ebx
jle 0x1f276
movl 0x8(%rsp), %ebx
movq 0x10(%rsp), %r13
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
cmpl $0x0, 0x10(%rsp)
jle 0x1f25d
xorps %xmm0, %xmm0
xorl %ebp, %ebp
movsd %xmm0, (%rsp)
movq (%r14,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl %ebp, %esi
callq 0x2ed6a
mulsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %rbp
cmpq %rbp, %r13
jne 0x1f21b
jmp 0x1f260
xorps %xmm0, %xmm0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq %rbx, %r15
jne 0x1f20f
movq %r12, %rdi
callq 0x2f33a
movq 0x18(%rsp), %rsi
movq (%rsi), %rcx
movslq 0x8(%rsp), %rdx
movl %eax, (%rcx,%rdx,8)
movq %rsi, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: reduce_dimension_of_instancelist
Instanceptr reduce_dimension_of_instancelist(Instanceptr data, int howmany, matrix eigenvectors)
{
 /*!Last Changed 12.01.2008*/
 Instanceptr newlist = NULL, prev = NULL, newinst, tmp;
 tmp = data;
 while (tmp)
  {
   newinst = reduce_dimension_of_instance(tmp, howmany, eigenvectors);
   if (newlist)
     prev->next = newinst;
   else
     newlist = newinst;
   prev = newinst;
   tmp = tmp->next;
  }
 return newlist;
}

// Assembly:
testq %rdi, %rdi
je 0x1f2fe
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1f1cb
movq %rax, %rcx
testq %r12, %r12
je 0x1f2e0
movq %rcx, 0x10(%r13)
movq %r12, %rax
movq 0x10(%r15), %r15
movq %rax, %r12
movq %rcx, %r13
testq %r15, %r15
jne 0x1f2c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: matrix_to_instancelist
Instanceptr matrix_to_instancelist(matrix m, Instanceptr data)
{
 /*!Last Changed 16.01.2008*/
 Instanceptr newinst, newlist = NULL, tmp, prev = NULL; 
 int i, index = 0;
 tmp = data;
 while (tmp)
  {
   newinst = empty_instance(m.col + 1);
   for (i = 0; i < m.col; i++)
     newinst->values[i].floatvalue = m.values[index][i];
   newinst->values[m.col].stringindex = give_classno(tmp);
   if (newlist)
     prev->next = newinst;
   else
     newlist = newinst;
   prev = newinst;
   tmp = tmp->next;
   index++;
  }
 return newlist;
}

// Assembly:
testq %rdx, %rdx
je 0x1f3b6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
shrq $0x20, %r13
leal 0x1(%r13), %eax
movl %eax, 0x4(%rsp)
sarq $0x20, %rdi
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %rdi, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movl 0x4(%rsp), %edi
callq 0x15391
movq %rax, %r12
testl %r13d, %r13d
jle 0x1f370
xorl %eax, %eax
movq (%r14,%rbp,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq (%r12), %rcx
movsd %xmm0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1f356
movq %rbx, %rdi
callq 0x2f33a
movq (%r12), %rcx
movq 0x8(%rsp), %rdi
movl %eax, (%rcx,%rdi,8)
movq %r12, %rax
testq %r15, %r15
je 0x1f398
movq 0x10(%rsp), %rax
movq %r12, 0x10(%rax)
movq %r15, %rax
movq 0x10(%rbx), %rbx
incq %rbp
movq %rax, %r15
testq %rbx, %rbx
jne 0x1f33e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: reduce_dimension_of_covariance_matrix
void reduce_dimension_of_covariance_matrix(matrix* covariance, int howmany, matrix eigenvectors)
{
 matrix reduced, treduced, S1;
 reduced = matrix_partial(eigenvectors, 0, eigenvectors.row - 1, 0, howmany);
 treduced = matrix_transpose(reduced);
 matrix_free(reduced);
 S1 = matrix_multiply(treduced, *covariance);
 reduced = matrix_transpose(treduced);
 matrix_free(treduced);
 *covariance = matrix_multiply(S1, reduced);
 matrix_free(S1);
 matrix_free(reduced);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r9d
movq %rdi, %rbx
leal -0x1(%rdx), %eax
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x3ec9d
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x3ed5e
movq %rax, %r12
movq %rdx, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ed51
movq %rbx, (%rsp)
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3ee2f
movq %rax, %r14
movq %rdx, %r15
movq %r12, %rdi
movq %r13, %rsi
callq 0x3ed5e
movq %rax, %rbp
movq %rdx, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3ed51
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x3ee2f
movq (%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ed51
movq %rbp, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ed51
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: reduce_dimension_of_vector
void reduce_dimension_of_vector(matrix* vector, int howmany, matrix eigenvectors)
{
 matrix reduced, result;
 reduced = matrix_partial(eigenvectors, 0, eigenvectors.row - 1, 0, howmany);
 result = matrix_multiply(*vector, reduced);
 matrix_free(*vector);
 *vector = result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r9d
movq %rdi, %rbx
leal -0x1(%rdx), %eax
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x3ec9d
movq %rdx, %rcx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %rax, %rdx
callq 0x3ee2f
movq %rax, %r14
movq %rdx, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3ed51
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: reduce_dimension_of_instancelist_mds
Instanceptr reduce_dimension_of_instancelist_mds(Instanceptr data, int howmany, matrix eigenvectors, double* eigenvalues)
{
 /*!Last Changed 18.01.2008*/
 matrix c, x, dsqrt;
 Instanceptr newlist;
 c = matrix_partial(eigenvectors, 0, eigenvectors.row - 1, 0, howmany - 1);
 matrix_free(eigenvectors);
 dsqrt = matrix_diagonal(eigenvalues, howmany); 
 safe_free(eigenvalues);
 matrix_cell_power(&dsqrt, 0.5);
 x = matrix_multiply(c, dsqrt);
 matrix_free(dsqrt);
 matrix_free(c);
 newlist = matrix_to_instancelist(x, data);
 matrix_free(x);
 return newlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movl %esi, %ebx
movq %rdi, (%rsp)
leal -0x1(%rdx), %ecx
leal -0x1(%rbx), %r9d
movq %rdx, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x3ec9d
movq %rax, %r14
movq %rdx, %r15
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3ed51
movq %r12, %rdi
movl %ebx, %esi
callq 0x3fcef
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r12, %rdi
callq 0x3a180
movsd 0x867e3(%rip), %xmm0    # 0xa5d18
movq %rbx, %rdi
callq 0x3fc43
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ee2f
movq %rax, %r12
movq %rdx, %r13
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3ed51
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ed51
movq %r12, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x1f301
movq %rax, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3ed51
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: reduce_dimension_of_instancelist_lle
Instanceptr reduce_dimension_of_instancelist_lle(Instanceptr data, int howmany, matrix eigenvectors, double* eigenvalues)
{
 /*!Last Changed 19.01.2008*/
 matrix M;
 Instanceptr newlist;
 int i = eigenvectors.row - 1;
 while (eigenvalues[i] == 0.0)
   i--;
 M = matrix_partial(eigenvectors, 0, eigenvectors.row - 1, i - howmany + 1, i);
 matrix_free(eigenvectors);
 safe_free(eigenvalues);
 newlist = matrix_to_instancelist(M, data);
 matrix_free(M);
 return newlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leal -0x1(%rdx), %ecx
movslq %ecx, %rax
leaq (%r8,%rax,8), %rdx
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd (%rdx,%rax,8), %xmm1
decq %rax
ucomisd %xmm0, %xmm1
jne 0x1f5d2
jnp 0x1f5c2
leal (%r12,%rax), %r9d
movl %r12d, %edx
subl %esi, %edx
leal (%rdx,%rax), %r8d
incl %r8d
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3ec9d
movq %rax, %r13
movq %rdx, %rbp
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ed51
movq %r14, %rdi
callq 0x3a180
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1f301
movq %rax, %rbx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3ed51
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: multi_dimensional_scaling
matrix multi_dimensional_scaling(matrix distancematrix)
{
 /*!Last Changed 17.01.2008*/
 double *ddots, *drdot, ddotdot;
 matrix b;
 int r, s, N = distancematrix.row;
 b = matrix_alloc(N, N);
 matrix_cell_square(&distancematrix);
 ddotdot = matrix_sum_of_elements(distancematrix) / (N * N);
 ddots = matrix_average_columns(distancematrix);
 drdot = matrix_average_rows(distancematrix);
 for (r = 0; r < N; r++)
   for (s = 0; s < N; s++)
     b.values[r][s] = 0.5 * (drdot[r] + ddots[s] - ddotdot - distancematrix.values[r][s]);
 safe_free(ddots);
 safe_free(drdot);
 return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %rdi, (%r13)
movq %rsi, 0x8(%r13)
movl %ebx, %esi
callq 0x3d79d
movq %rax, %r14
movq %rdx, %r15
movq %r13, %rdi
callq 0x3fcb2
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x3fd49
movsd %xmm0, 0x8(%rsp)
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x3fe12
movq %rax, %r12
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x40040
movsd 0x8(%rsp), %xmm2
movq %rax, %r13
testl %ebx, %ebx
jle 0x1f703
movl %ebx, %eax
imull %ebx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movq 0x18(%rsp), %rax
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsd 0x8664e(%rip), %xmm0    # 0xa5d18
movq (%rax,%rcx,8), %rdx
movq (%r15,%rcx,8), %rsi
xorl %edi, %edi
movsd (%r13,%rcx,8), %xmm1
addsd (%r12,%rdi,8), %xmm1
subsd %xmm2, %xmm1
subsd (%rdx,%rdi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rbx
jne 0x1f6d4
incq %rcx
cmpq %rbx, %rcx
jne 0x1f6ca
movq %r12, %rdi
callq 0x3a180
movq %r13, %rdi
callq 0x3a180
movq %r14, %rax
movq %r15, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: local_covariance_matrix
matrix local_covariance_matrix(Datasetptr d, Instanceptr inst, Instanceptr traindata, matrix neighborhood, int index)
{
 /*!Last Changed 19.01.2008*/
 matrix C;
 int i, j, t, k, p, size = matrix_sum_row(neighborhood, index);
 Instanceptr temp1, temp2;
 double sum;
 C = matrix_alloc(size, size);
 for (i = 0, j = 0, temp1 = traindata; i < neighborhood.row; i++, temp1 = temp1->next)
   if (neighborhood.values[index][i] == 1)
    {
     for (t = 0, k = 0, temp2 = traindata; t < neighborhood.row; t++, temp2 = temp2->next)
       if (neighborhood.values[index][t] == 1)
        {
         sum = 0.0;
         for (p = 0; p < d->multifeaturecount - 1; p++)
           sum += (real_feature(inst, p) - real_feature(temp1, p)) * (real_feature(inst, p) - real_feature(temp2, p));
         C.values[j][k] = sum;
         k++;
        }
     j++;
    }
 return C;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebx
movq %rcx, %r14
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movq %rcx, %rdi
movq %r8, 0x30(%rsp)
movq %r8, %rsi
movl %r9d, %edx
callq 0x40019
cvttsd2si %xmm0, %edi
movl %edi, %esi
callq 0x3d79d
movq %rax, 0x38(%rsp)
movq %rdx, 0x20(%rsp)
movq %r14, (%rsp)
testl %r14d, %r14d
jle 0x1f8d5
movslq %ebx, %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, (%rsp)
xorl %edx, %edx
xorl %esi, %esi
movq 0x18(%rsp), %r15
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%rdx,8), %xmm0
ucomisd 0x85d6c(%rip), %xmm0    # 0xa5520
jne 0x1f8c4
jp 0x1f8c4
movq %rdx, 0x40(%rsp)
movl %esi, 0x14(%rsp)
movslq %esi, %rax
movq %rax, 0x48(%rsp)
xorl %r14d, %r14d
movq 0x18(%rsp), %rbp
xorl %edx, %edx
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd 0x85d29(%rip), %xmm0    # 0xa5520
jne 0x1f8a8
jp 0x1f8a8
movq %rdx, 0x50(%rsp)
xorpd %xmm0, %xmm0
cmpl $0x2, 0x1c0(%r13)
jl 0x1f88b
xorl %ebx, %ebx
movsd %xmm0, 0x60(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2ed6a
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2ed6a
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2ed6a
movsd %xmm0, 0x58(%rsp)
movq %rbp, %rdi
movl %ebx, %esi
callq 0x2ed6a
movsd 0x58(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x60(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm0
incl %ebx
movl 0x1c0(%r13), %eax
decl %eax
cmpl %eax, %ebx
jl 0x1f818
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rsp), %rdx
movslq %edx, %rdx
movsd %xmm0, (%rax,%rdx,8)
incl %edx
incq %r14
movq 0x10(%rbp), %rbp
cmpq (%rsp), %r14
jne 0x1f7db
movl 0x14(%rsp), %esi
incl %esi
movq 0x40(%rsp), %rdx
incq %rdx
movq 0x10(%r15), %r15
cmpq (%rsp), %rdx
jne 0x1f799
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: local_contributions_of_neighbors
matrix local_contributions_of_neighbors(Datasetptr d, Instanceptr traindata, matrix neighborhood)
{
 /*!Last Changed 19.01.2008*/
 matrix w, C;
 Instanceptr tmp = traindata;
 double denominator, nominator;
 int i = 0, j, t;
 w = matrix_alloc(neighborhood.row, neighborhood.col);
 while (tmp)
  {
   C = local_covariance_matrix(d, tmp, traindata, neighborhood, i);
   matrix_inverse(&C);
   denominator = matrix_sum_of_elements(C);
   t = 0;
   for (j = 0; j < neighborhood.col; j++)
     if (neighborhood.values[i][j])
      {
       nominator = matrix_sum_row(C, t);
       w.values[i][j] = nominator / denominator;
       t++;
      }
     else
       w.values[i][j] = 0.0;
   i++;
   tmp = tmp->next;
   matrix_free(C);
  }
 return w;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
movq %rdx, %r13
shrq $0x20, %r13
movq %rdx, 0x30(%rsp)
movl %edx, %edi
movl %r13d, %esi
callq 0x3d79d
movq %rax, 0x20(%rsp)
movq %rdx, %rbp
movq %r14, 0x18(%rsp)
testq %r14, %r14
je 0x1fa08
xorl %r12d, %r12d
movq 0x18(%rsp), %r14
movq 0x28(%rsp), %rdi
movq %r14, 0x38(%rsp)
movq %r14, %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %rbx, %r8
movl %r12d, %r9d
callq 0x1f727
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x409b7
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3fd49
movsd %xmm0, 0x40(%rsp)
testl %r13d, %r13d
jle 0x1f9e4
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rbx,%r12,8), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd 0x86365(%rip), %xmm0    # 0xa5d08
jne 0x1f9a7
jnp 0x1f9cf
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
callq 0x40019
divsd 0x40(%rsp), %xmm0
movq (%rbp,%r12,8), %rax
movsd %xmm0, (%rax,%r15,8)
incl %r14d
jmp 0x1f9dc
movq (%rbp,%r12,8), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x1f991
incq %r12
movq 0x38(%rsp), %r14
movq 0x10(%r14), %r14
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3ed51
testq %r14, %r14
jne 0x1f93b
movq 0x20(%rsp), %rax
movq %rbp, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dimreduction.c
// Function: calculate_m_for_lle
matrix calculate_m_for_lle(matrix w)
{
 /*!Last Changed 19.01.2008*/
 int i, j, k;
 double sum;
 matrix M = matrix_alloc(w.row, w.col);
 for (i = 0; i < w.row; i++)
   for (j = 0; j < w.col; j++)
    {
     sum = kronecker_delta(i, j) - w.values[i][j] - w.values[j][i];
     for (k = 0; k < w.row; k++)
       sum += w.values[k][i] * w.values[k][j];
     M.values[i][j] = sum;
    }
 return M;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
shrq $0x20, %r15
movl %r15d, %esi
callq 0x3d79d
movq %rax, (%rsp)
movq %rdx, %r13
testl %r14d, %r14d
jle 0x1fab8
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
testl %r15d, %r15d
jle 0x1fab0
xorl %r12d, %r12d
movl %ebp, %edi
movl %r12d, %esi
callq 0x3a524
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%rbx,%rbp,8), %rax
subsd (%rax,%r12,8), %xmm0
movq (%rbx,%r12,8), %rax
subsd (%rax,%rbp,8), %xmm0
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
movsd (%rcx,%rbp,8), %xmm1
mulsd (%rcx,%r12,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x1fa82
movq (%r13,%rbp,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r15, %r12
jne 0x1fa5c
incq %rbp
cmpq %r14, %rbp
jne 0x1fa54
movq (%rsp), %rax
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/distributions.c
// Function: beta
double beta(double* x, int count)
{
 /*Last Changed 28.02.2007*/
 double sum = 0.0, result = 0.0;
 int i;
 for (i = 0; i < count; i++)
  {
   result += gammln(x[i]);
   sum += x[i];
  }
 result -= gammln(sum);
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testl %esi, %esi
jle 0x1fb28
movq %rdi, %rbx
movl %esi, %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd (%rbx,%r15,8), %xmm0
callq 0x1fb55
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm1
addsd (%rbx,%r15,8), %xmm1
incq %r15
cmpq %r15, %r14
jne 0x1faf3
jmp 0x1fb35
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
callq 0x1fb55
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/distributions.c
// Function: gammln
double gammln(double x)
{
 /*Last Changed 28.02.2007*/
 /*Returns ln of gamma(x)*/
 double y,tmp,ser;
 double cof[6]={76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5};
 int j;
 y = x;
 tmp = x + 5.5;
 tmp -= (x + 0.5) * log(tmp);
 ser = 1.000000000190015;
 for (j = 0; j <= 5; j++) 
   ser += cof[j] / ++y;
 return -tmp + log(2.5066282746310005 * ser / x);
}

// Assembly:
subq $0x48, %rsp
movapd %xmm0, %xmm1
movsd %xmm0, 0x8(%rsp)
movaps 0x87ed6(%rip), %xmm0    # 0xa7a40
movaps %xmm0, 0x10(%rsp)
movaps 0x87eda(%rip), %xmm0    # 0xa7a50
movaps %xmm0, 0x20(%rsp)
movaps 0x87ede(%rip), %xmm0    # 0xa7a60
movaps %xmm0, 0x30(%rsp)
movsd 0x87f21(%rip), %xmm0    # 0xa7ab0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
callq 0x4160
movsd 0x8(%rsp), %xmm5
movapd %xmm0, %xmm1
movsd 0x87f09(%rip), %xmm0    # 0xa7ab8
xorl %eax, %eax
movsd 0x85967(%rip), %xmm2    # 0xa5520
movapd %xmm5, %xmm3
movsd 0x10(%rsp,%rax,8), %xmm4
addsd %xmm2, %xmm3
divsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rax
cmpq $0x6, %rax
jne 0x1fbbd
movsd 0x86138(%rip), %xmm2    # 0xa5d18
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm2
movsd (%rsp), %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
mulsd 0x87ec2(%rip), %xmm0    # 0xa7ac0
divsd %xmm5, %xmm0
callq 0x4160
subsd (%rsp), %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/distributions.c
// Function: z_normal
double z_normal(double z)
{/*Returns the probability*/
 double  y, x, w;
 if (z == 0.0)
   x = 0.0;
 else
  {
   y = 0.5 * fabs (z);
   if (y >= (Z_MAX * 0.5))
     x = 1.0;
   else
     if (y < 1.0)
      {
       w = y*y;
       x = ((((((((0.000124818987 * w-0.001075204047) * w +0.005198775019) * w-0.019198292004) * w +0.059054035642) * w-0.151968751364) * w +0.319152932694) * w-0.531923007300) * w +0.797884560593) * y * 2.0;
      }
     else
      {
       y -= 2.0;
       x = (((((((((((((-0.000045255659 * y+0.000152529290) * y -0.000019538132) * y-0.000676904986) * y +0.001390604284) * y-0.000794620820) * y -0.002034254874) * y+0.006549791214) * y -0.010557625006) * y+0.011630447319) * y -0.009279453341) * y+0.005353579108) * y -0.002141268741) * y+0.000535310849) * y +0.999936657524;
      }
  }
 if (z > 0.0)
   return ((x + 1.0) * 0.5);
 else
   return ((1.0 - x) * 0.5);
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
xorpd %xmm2, %xmm2
jne 0x1fecc
jnp 0x20031
movapd 0x8630c(%rip), %xmm3    # 0xa61e0
andpd %xmm1, %xmm3
mulsd 0x85e38(%rip), %xmm3    # 0xa5d18
movsd 0x85638(%rip), %xmm2    # 0xa5520
ucomisd 0x87bf8(%rip), %xmm3    # 0xa7ae8
jae 0x20031
ucomisd %xmm3, %xmm2
jbe 0x1ff79
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
movsd 0x87c64(%rip), %xmm2    # 0xa7b70
mulsd %xmm4, %xmm2
addsd 0x87c60(%rip), %xmm2    # 0xa7b78
mulsd %xmm4, %xmm2
addsd 0x87c5c(%rip), %xmm2    # 0xa7b80
mulsd %xmm4, %xmm2
addsd 0x87c58(%rip), %xmm2    # 0xa7b88
mulsd %xmm4, %xmm2
addsd 0x87c54(%rip), %xmm2    # 0xa7b90
mulsd %xmm4, %xmm2
addsd 0x87c50(%rip), %xmm2    # 0xa7b98
mulsd %xmm4, %xmm2
addsd 0x87c4c(%rip), %xmm2    # 0xa7ba0
mulsd %xmm4, %xmm2
addsd 0x87c48(%rip), %xmm2    # 0xa7ba8
mulsd %xmm4, %xmm2
addsd 0x87c44(%rip), %xmm2    # 0xa7bb0
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm2
jmp 0x20031
addsd 0x87b6f(%rip), %xmm3    # 0xa7af0
movsd 0x87b6f(%rip), %xmm2    # 0xa7af8
mulsd %xmm3, %xmm2
addsd 0x87b6b(%rip), %xmm2    # 0xa7b00
mulsd %xmm3, %xmm2
addsd 0x87b67(%rip), %xmm2    # 0xa7b08
mulsd %xmm3, %xmm2
addsd 0x87b63(%rip), %xmm2    # 0xa7b10
mulsd %xmm3, %xmm2
addsd 0x87b5f(%rip), %xmm2    # 0xa7b18
mulsd %xmm3, %xmm2
addsd 0x87b5b(%rip), %xmm2    # 0xa7b20
mulsd %xmm3, %xmm2
addsd 0x87b57(%rip), %xmm2    # 0xa7b28
mulsd %xmm3, %xmm2
addsd 0x87b53(%rip), %xmm2    # 0xa7b30
mulsd %xmm3, %xmm2
addsd 0x87b4f(%rip), %xmm2    # 0xa7b38
mulsd %xmm3, %xmm2
addsd 0x87b4b(%rip), %xmm2    # 0xa7b40
mulsd %xmm3, %xmm2
addsd 0x87b47(%rip), %xmm2    # 0xa7b48
mulsd %xmm3, %xmm2
addsd 0x87b43(%rip), %xmm2    # 0xa7b50
mulsd %xmm3, %xmm2
addsd 0x87b3f(%rip), %xmm2    # 0xa7b58
mulsd %xmm3, %xmm2
addsd 0x87b3b(%rip), %xmm2    # 0xa7b60
mulsd %xmm3, %xmm2
addsd 0x87b37(%rip), %xmm2    # 0xa7b68
movapd 0x86197(%rip), %xmm3    # 0xa61d0
xorpd %xmm2, %xmm3
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm3, %xmm0
orpd %xmm2, %xmm0
addsd 0x854ca(%rip), %xmm0    # 0xa5520
mulsd 0x85cba(%rip), %xmm0    # 0xa5d18
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/distributions.c
// Function: chi_square_inverse
double chi_square_inverse(double p,int freedom)
{
 double  minchisq = 0.0;
 double  maxchisq = CHI_MAX;
 double  chisqval;
 if (p <= 0.0)
   return (maxchisq);
 else
   if (p >= 1.0)
     return (0.0);
 chisqval = freedom / sqrt (p);    /* fair first value */
 while (maxchisq - minchisq > CHI_EPSILON)
  {
   if (chi_square (freedom , chisqval) < p)
     maxchisq = chisqval;
   else
     minchisq = chisqval;
   chisqval = (maxchisq + minchisq) * 0.5;
  }
 return (chisqval);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x200a3
ucomisd 0x854aa(%rip), %xmm0    # 0xa5520
jae 0x2013b
movl %edi, %ebx
xorps %xmm2, %xmm2
cvtsi2sd %edi, %xmm2
xorpd %xmm3, %xmm3
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
ucomisd %xmm3, %xmm0
movsd %xmm0, 0x10(%rsp)
jb 0x200b0
sqrtsd %xmm0, %xmm0
jmp 0x200bf
movsd 0x87b0d(%rip), %xmm2    # 0xa7bb8
jmp 0x2013b
movapd %xmm2, (%rsp)
callq 0x4300
movapd (%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x87aed(%rip), %xmm1    # 0xa7bb8
movsd %xmm1, 0x18(%rsp)
movapd %xmm2, (%rsp)
movl %ebx, %edi
movapd %xmm2, %xmm0
callq 0x1fc11
movapd (%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
ucomisd %xmm0, %xmm2
movapd %xmm3, %xmm1
ja 0x200fc
movsd 0x18(%rsp), %xmm1
cmpltsd %xmm2, %xmm0
movapd 0x20(%rsp), %xmm4
andpd %xmm0, %xmm4
andnpd %xmm3, %xmm0
orpd %xmm0, %xmm4
movapd %xmm1, %xmm2
addsd %xmm4, %xmm2
mulsd 0x85bf5(%rip), %xmm2    # 0xa5d18
movapd %xmm1, %xmm0
movapd %xmm4, 0x20(%rsp)
subsd %xmm4, %xmm0
ucomisd 0x87a87(%rip), %xmm0    # 0xa7bc0
ja 0x200cb
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/distributions.c
// Function: dirichlet
double dirichlet(Instanceptr x, double* alpha)
{
 /*Last Changed 28.02.2007*/
 int i;
 double result = 1.0;
 for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
   result *= pow(real_feature(x, i), alpha[i] - 1);
 result /= beta(alpha, current_dataset->multifeaturecount - 1);
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xb5719(%rip), %r12     # 0xd5870
movq (%r12), %rax
movl 0x1c0(%rax), %esi
cmpl $0x2, %esi
jl 0x201bd
movq %rdi, %r14
movsd 0x853af(%rip), %xmm0    # 0xa5520
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x2ed6a
movsd (%rbx,%r15,8), %xmm1
addsd 0x85c16(%rip), %xmm1    # 0xa5da8
callq 0x42f0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r15
movq (%r12), %rax
movslq 0x1c0(%rax), %rsi
decq %rsi
cmpq %rsi, %r15
jl 0x20179
jmp 0x201cc
decl %esi
movsd 0x85359(%rip), %xmm0    # 0xa5520
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1fad0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq