LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: level_of_decision_tree
void level_of_decision_tree(Decisionnodeptr node)
{
 int i;
 if (node)
  {
   if (node->parent)
     node->y = node->parent->y + 1;
   else
     node->y = 0;
   if (node->featureno >= 0 && current_dataset->features[node->featureno].type == STRING)
     for (i = 0; i < current_dataset->features[node->featureno].valuecount; i++)
       level_of_decision_tree(&(node->string[i]));
   else
    {
     level_of_decision_tree(node->left);
     level_of_decision_tree(node->right);       
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2b5b7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2b4ff
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x138(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x138(%rax)
jmp 0x2b50d
movq -0x8(%rbp), %rax
movl $0x0, 0x138(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0x2b59c
leaq 0xda31e(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x2b59c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xda2ed(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movq -0x8(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x2b59a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x2b4c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b549
jmp 0x2b5b5
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2b4c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2b4c0
jmp 0x2b5b7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/decisiontree.c
// Function: level_of_node
int level_of_node(Decisionnodeptr node)
{
 /*!Last Changed 08.06.2006*/
 int level = 0;
 Decisionnodeptr tmp = node;
 while (tmp->parent)
  {
   level++;
   tmp = tmp->parent;
  }
 return level;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2b5f9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b5d7
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2b6b5
movq -0x8(%rbp), %rdi
callq 0x2b5c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2b639
movl $0x1, -0x18(%rbp)
jmp 0x2b69d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x2b673
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2b666
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
jmp 0x2b671
movl -0x14(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b69b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x2b68e
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
jmp 0x2b699
movl -0x14(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b69b
jmp 0x2b69d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2b6d6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b600
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b600
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x172a0
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movups -0x88(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2cda0
movq %rax, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movups -0x98(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x59ea0
movq -0x70(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x9c(%rbp)
testl %eax, %eax
je 0x2bb69
jmp 0x2bb5c
movl -0x9c(%rbp), %eax
subl $0x1, %eax
je 0x2bb89
jmp 0x2bbab
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x5fb50
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2bbab
movq -0x70(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x2c(%rbp), %rcx
callq 0x5fba0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x59ea0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x68(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x2cba0
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
addl $0x1, %esi
movq -0x78(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e1d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
jb 0x2c028
jmp 0x2c018
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0x2c08d
jmp 0x2c12e
movl $0x18, %edi
leaq 0xb852f(%rip), %rsi     # 0xe4563
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
leaq 0xb854b(%rip), %rdi     # 0xe4594
callq 0x78f10
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq 0xb6575(%rip), %rdi     # 0xe25d2
callq 0x79040
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
leaq 0xb8536(%rip), %rdi     # 0xe45a8
callq 0x792b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c136
movl $0x28, %edi
leaq 0xb84ca(%rip), %rsi     # 0xe4563
movl $0xc, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
leaq 0xb84e6(%rip), %rdi     # 0xe4594
callq 0x78f10
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
leaq 0xb6510(%rip), %rdi     # 0xe25d2
callq 0x79040
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
leaq 0xb84d1(%rip), %rdi     # 0xe45a8
callq 0x792b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
leaq 0xb66d4(%rip), %rdi     # 0xe27c0
callq 0x79040
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
leaq 0xb6436(%rip), %rdi     # 0xe2537
callq 0x78f10
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
leaq 0xb84a6(%rip), %rdi     # 0xe45bc
callq 0x792b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c136
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/dimreduction.c
// Function: get_dimension_reduction_algorithm_index
int get_dimension_reduction_algorithm_index(char* algname)
{
 /*!Last Changed 12.01.2008*/
 int i;
 for (i = 0; i < DIMENSION_REDUCTION_ALGORITHM_COUNT; i++)
   if (strIcmp(algname, dimension_reduction_algorithms[i].name) == 0)
     return i;
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x2c1c2
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xd8958(%rip), %rax     # 0x104af0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0x2c1b5
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2c1c9
jmp 0x2c1b7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c183
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x449f0
movl %eax, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2c263
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2c310
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x263c0
cmpl $0x0, %eax
je 0x2c24c
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ea0
jmp 0x2c263
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ea0
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
jmp 0x2c1ff
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x2c273
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x2c279
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x2c304
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2c310
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x263c0
cmpl $0x0, %eax
je 0x2c2de
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x2c2e4
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ea0
jmp 0x2c298
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x172a0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x5b800
movsd %xmm0, -0x20(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x59ea0
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd 0xb675a(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jge 0x2c5f8
movq -0x8(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x2c610
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x263c0
cmpl $0x0, %eax
je 0x2c5b8
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x2c5c2
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd 0xb66cc(%rip), %xmm1    # 0xe2ca0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59ea0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2c560
movsd -0x30(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2c711
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2c6f5
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x2c6c4
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x442e0
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2c6c4
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd 0xb595b(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2c6dc
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2c6de
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2c67a
jmp 0x2c6f7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2c65f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
addl $0x1, %edi
callq 0x1e140
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2c7de
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2c7bb
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x42c40
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2c768
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2c74d
movq -0x18(%rbp), %rdi
callq 0x43530
movl %eax, %edx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2c891
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0x2c720
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2c873
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2c87b
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2c83f
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2c984
movl -0xc(%rbp), %edi
addl $0x1, %edi
callq 0x1e140
movq %rax, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2c92c
movq -0x8(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2c8f4
movq -0x30(%rbp), %rdi
callq 0x43530
movl %eax, %edx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
cmpq $0x0, -0x28(%rbp)
je 0x2c95a
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2c962
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2c8d3
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl -0x1c(%rbp), %r9d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x59de0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ed0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ea0
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x59fe0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59ed0
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59ea0
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x59fe0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
movq -0x98(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x59ea0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59ea0
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl -0x1c(%rbp), %r9d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x59de0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x59fe0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl -0x1c(%rbp), %r9d
subl $0x1, %r9d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x59de0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x59ea0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5b1c0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x52e80
leaq -0x58(%rbp), %rdi
movsd 0xb5d7b(%rip), %xmm0    # 0xe29b8
callq 0x5b090
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x59fe0
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x59ea0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
movq -0x18(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2c8a0
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x59ea0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2cd17
jp 0x2cd17
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2ccf4
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl -0x44(%rbp), %r8d
subl -0x1c(%rbp), %r8d
addl $0x1, %r8d
movl -0x44(%rbp), %r9d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x59de0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x59ea0
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2c8a0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x59ea0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %edi
movl -0x44(%rbp), %esi
callq 0x57fc0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5b120
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b240
movl -0x44(%rbp), %eax
imull -0x44(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b3e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b730
movq %rax, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x2ceb3
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x2cea3
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm1
subsd -0x38(%rbp), %xmm1
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x40(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm1
movsd 0xb5b39(%rip), %xmm0    # 0xe29b8
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x40(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2ce3b
jmp 0x2cea5
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2ce2c
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x2d288
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x5c(%rbp), %r9d
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x2cee0
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5c470
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5b240
movsd %xmm0, -0x50(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2d261
movq -0x18(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x60(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2d1fa
jp 0x2d1fa
jmp 0x2d239
movl -0x64(%rbp), %edx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5b6d0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
divsd -0x50(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x60(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x2d251
movq -0x8(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x60(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2d253
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x2d1cc
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59ea0
jmp 0x2d15d
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x57fc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2d3b5
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2d3a5
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x532b0
cvtsi2sd %eax, %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2d37d
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2d32e
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2d2dd
jmp 0x2d3a7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d2ca
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2d43c
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2d470
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d3f6
movsd -0x18(%rbp), %xmm0
callq 0x2d470
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x4050
movsd 0xb71ab(%rip), %xmm0    # 0xe4640
movsd %xmm0, -0x50(%rbp)
movsd 0xb7196(%rip), %xmm0    # 0xe4638
movsd %xmm0, -0x48(%rbp)
movsd 0xb7181(%rip), %xmm0    # 0xe4630
movsd %xmm0, -0x40(%rbp)
movsd 0xb716c(%rip), %xmm0    # 0xe4628
movsd %xmm0, -0x38(%rbp)
movsd 0xb7157(%rip), %xmm0    # 0xe4620
movsd %xmm0, -0x30(%rbp)
movsd 0xb7142(%rip), %xmm0    # 0xe4618
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0xb7123(%rip), %xmm0    # 0xe4610
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xb54b9(%rip), %xmm0    # 0xe29b8
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x4120
movaps %xmm0, %xmm2
movsd -0x60(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xb70bc(%rip), %xmm0    # 0xe4608
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x54(%rbp)
cmpl $0x5, -0x54(%rbp)
jg 0x2d593
movslq -0x54(%rbp), %rax
movsd -0x50(%rbp,%rax,8), %xmm0
movsd 0xb4aa8(%rip), %xmm1    # 0xe2018
addsd -0x10(%rbp), %xmm1
movsd %xmm1, -0x10(%rbp)
divsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x2d558
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0xb708c(%rip), %xmm0    # 0xe4648
mulsd -0x20(%rbp), %xmm0
divsd -0x8(%rbp), %xmm0
callq 0x4120
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
addsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movl %edi, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xb6ae8(%rip), %xmm0    # 0xe4738
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jb 0x2dc6e
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2dd25
movsd -0x10(%rbp), %xmm0
movsd 0xb439d(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jb 0x2dc8e
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2dd25
jmp 0x2dc90
cvtsi2sdl -0x14(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0xb6a79(%rip), %xmm1    # 0xe4740
ucomisd %xmm1, %xmm0
jbe 0x2dd1b
movl -0x14(%rbp), %edi
movsd -0x30(%rbp), %xmm0
callq 0x2d5e0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2dcf4
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x2dcfe
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd 0xb4ca8(%rip), %xmm1    # 0xe29b8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x2dcb5
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd 0xb42d0(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0xd7ae2(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2ddad
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x42c40
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0xb4289(%rip), %xmm2    # 0xe2018
subsd %xmm2, %xmm1
callq 0x4290
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2dd54
movq -0x10(%rbp), %rdi
leaq 0xd7a88(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %esi
subl $0x1, %esi
callq 0x2d3d0
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/distributions.c
// Function: f_distribution_inverse
double f_distribution_inverse(double p, int freedom1, int freedom2)
{/*Finds the value*/
 double  fval;
 double  maxf = F_MAX;     /* maximum F ratio */
 double  minf = 0.0;       /* minimum F ratio */
 if (p <= 0.0 || p >= 1.0)
   return (0.0);
 if (freedom1 == freedom2 && freedom1 > 2500)
   return 1 + 4.0 / freedom1;
 fval = 1.0 / p;             /* the smaller the p, the larger the F */
 while (fabs (maxf - minf) > F_EPSILON)
  {
   if (f_distribution (fval, freedom1, freedom2) < p)     /* F too large */
     maxf = fval;
   else                              /* F too small */
     minf = fval;
   fval = (maxf + minf) * 0.5;
  }
 return (fval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movsd 0xb65d5(%rip), %xmm0    # 0xe4750
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jae 0x2e1a5
movsd -0x10(%rbp), %xmm0
movsd 0xb3e79(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jb 0x2e1b2
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2e27a
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x2e1ea
cmpl $0x9c4, -0x14(%rbp)     # imm = 0x9C4
jle 0x2e1ea
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0xb48b0(%rip), %xmm1    # 0xe2a80
divsd %xmm0, %xmm1
movsd 0xb3e3c(%rip), %xmm0    # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2e27a
movsd 0xb3e26(%rip), %xmm0    # 0xe2018
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movaps 0xb4c53(%rip), %xmm1    # 0xe2e60
pand %xmm1, %xmm0
movsd 0xb6527(%rip), %xmm1    # 0xe4740
ucomisd %xmm1, %xmm0
jbe 0x2e270
movsd -0x20(%rbp), %xmm0
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x2ddf0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2e249
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x2e253
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd 0xb4753(%rip), %xmm1    # 0xe29b8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x2e1fc
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)