LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x1c5aa
testl %eax, %eax
jne 0x1c5be
movsd 0x18(%r13), %xmm0
movq %r12, %rdi
callq 0x1ca9a
jmp 0x1c5b6
movl 0x20(%r13), %esi
movq %r12, %rdi
callq 0x1c898
movq %rax, %rbx
movq %rdx, %r14
jmp 0x1c5be
movq %r15, 0x18(%rsp)
movq %r15, %rdi
movq %r12, 0x10(%rsp)
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1d281
movq %rax, %r15
movq %rdx, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3929f
movq %r15, %rdi
movq %r12, %rsi
callq 0x1d3a7
movq %rax, %rbp
movq %rdx, %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3929f
movl 0x10(%r13), %eax
cmpl $0x1, %eax
je 0x1c635
testl %eax, %eax
movq 0x8(%rsp), %r15
jne 0x1c660
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x3c5c1
movq %rax, %r14
movl (%r13), %eax
movl %eax, 0x4(%rsp)
jmp 0x1c660
movsd 0x78ee3(%rip), %xmm0    # 0x95520
subsd 0x8(%r13), %xmm0
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rcx
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x3c5f6
movq %rax, %r14
movq 0x8(%rsp), %r15
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x3929f
movl 0x4(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %r14, %r8
callq 0x1cf20
movq %rax, %rbx
movl 0x4(%rsp), %esi
incl %esi
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
callq 0x1414c
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_O2/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 0x1c701
leaq 0x7b250(%rip), %rsi     # 0x97913
pushq $0x18
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %rbx
leaq 0x7b26c(%rip), %rdi     # 0x97944
callq 0x4cd35
movl %eax, (%rbx)
leaq 0x791b5(%rip), %rdi     # 0x9589b
callq 0x4cdcf
movsd %xmm0, 0x8(%rbx)
leaq 0x7b261(%rip), %rdi     # 0x97958
callq 0x4cf11
movl %eax, 0x10(%rbx)
jmp 0x1c77f
addl $-0x3, %edi
cmpl $0x2, %edi
jae 0x1c77d
leaq 0x7b203(%rip), %rsi     # 0x97913
pushq $0x28
popq %rdi
pushq $0xc
popq %rdx
callq 0x34f59
movq %rax, %rbx
leaq 0x7b21f(%rip), %rdi     # 0x97944
callq 0x4cd35
movl %eax, (%rbx)
leaq 0x79168(%rip), %rdi     # 0x9589b
callq 0x4cdcf
movsd %xmm0, 0x8(%rbx)
leaq 0x7b214(%rip), %rdi     # 0x97958
callq 0x4cf11
movl %eax, 0x10(%rbx)
leaq 0x792f8(%rip), %rdi     # 0x95a4b
callq 0x4cdcf
movsd %xmm0, 0x18(%rbx)
leaq 0x790ce(%rip), %rdi     # 0x95832
callq 0x4cd35
movl %eax, 0x20(%rbx)
leaq 0x7b1f9(%rip), %rdi     # 0x9796c
callq 0x4cf11
movl %eax, 0x24(%rbx)
jmp 0x1c77f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
callq 0x2c3cc
movl %eax, %r14d
pushq $0x1
popq %rbp
cmpl %r14d, %ebp
jge 0x1c82a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c898
movq %rax, %r15
movq %rdx, %r12
movq %rax, %rdi
movq %rdx, %rsi
callq 0x192c6
movl %eax, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0x3929f
testl %r13d, %r13d
jne 0x1c82a
addl %ebp, %ebp
jmp 0x1c7f3
cmpl %r14d, %ebp
cmovll %ebp, %r14d
pushq $0x2
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %r15d
movl %eax, %ebp
addl %r14d, %ebp
movl %ebp, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
cmpl %r15d, %eax
je 0x1c886
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x1c898
movq %rax, %r12
movq %rdx, %r13
movq %rax, %rdi
movq %rdx, %rsi
callq 0x192c6
testl %eax, %eax
cmovel %ebp, %r15d
cmovnel %ebp, %r14d
leal (%r14,%r15), %ebp
movq %r12, %rdi
movq %r13, %rsi
callq 0x3929f
jmp 0x1c841
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_O2/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, 0x4(%rsp)
movq %rdi, %r15
callq 0x2c3cc
movl %eax, %r12d
movl %eax, %edi
movl %eax, %esi
callq 0x380d3
movq %rax, 0x8(%rsp)
movq %rdx, %r14
xorl %ebx, %ebx
testl %r12d, %r12d
movl $0x0, %r9d
cmovgl %r12d, %r9d
movl %r12d, %ebp
movq %r15, 0x10(%rsp)
movq %r15, %r12
movq %r9, 0x18(%rsp)
cmpq %r9, %rbx
je 0x1c969
movq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl 0x4(%rsp), %edx
callq 0x2d78f
addsd 0x794da(%rip), %xmm0    # 0x95de0
movsd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x1c957
cmpq %r15, %rbx
jne 0x1c91f
movq (%r14,%rbx,8), %rax
jmp 0x1c944
movq %r12, %rdi
movq %r13, %rsi
callq 0x2beed
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq (%r14,%rbx,8), %rax
jbe 0x1c944
movsd 0x78bde(%rip), %xmm0    # 0x95520
jmp 0x1c948
xorpd %xmm0, %xmm0
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq 0x10(%r13), %r13
jmp 0x1c90f
incq %rbx
movq 0x10(%r12), %r12
movq 0x18(%rsp), %r9
jmp 0x1c8e5
pushq $0x1
popq %rax
xorl %ecx, %ecx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
cmpq %r9, %rcx
je 0x1c9b0
movq %rax, %rsi
cmpl %esi, %ebp
jle 0x1c9a8
movq (%r14,%rcx,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%r14,%rsi,8), %r8
ucomisd (%r8,%rcx,8), %xmm0
jne 0x1c99b
jnp 0x1c9a3
movq %rdx, (%r8,%rcx,8)
movq %rdx, (%rdi,%rsi,8)
incq %rsi
jmp 0x1c980
incq %rcx
incq %rax
jmp 0x1c978
movq 0x8(%rsp), %rax
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_O2/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 0xfdf0
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x3a221
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
movsd %xmm1, 0x10(%rsp)
addsd %xmm2, %xmm0
movsd %xmm0, (%rsp)
pushq $0x1e
popq %rbp
subl $0x1, %ebp
jb 0x1ca89
movsd (%rsp), %xmm0
mulsd 0x792f3(%rip), %xmm0    # 0x95d20
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x1ca9a
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x192c6
testl %eax, %eax
je 0x1ca62
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
jmp 0x1ca6d
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
jmp 0x1ca1b
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movq %rdi, %r13
callq 0x2c3cc
movl %eax, %r12d
movl %eax, %edi
movl %eax, %esi
callq 0x380d3
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
movq %rax, 0x18(%rsp)
movq %rdx, %r15
movl %r12d, %ebx
movq %r13, 0x10(%rsp)
movq %r13, %r12
cmpq 0x18(%rsp), %r14
je 0x1cb48
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
cmpq %rbp, %rbx
je 0x1cb3e
cmpq %rbp, %r14
jne 0x1cb07
movq (%r15,%r14,8), %rax
jmp 0x1cb2c
movq %r12, %rdi
movq %r13, %rsi
callq 0x2beed
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq (%r15,%r14,8), %rax
jbe 0x1cb2c
movsd 0x789f6(%rip), %xmm0    # 0x95520
jmp 0x1cb30
xorpd %xmm0, %xmm0
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movq 0x10(%r13), %r13
jmp 0x1caf7
incq %r14
movq 0x10(%r12), %r12
jmp 0x1cae9
movq 0x8(%rsp), %rax
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movl %esi, %ebp
movq %rdi, %r15
leal 0x1(%rbp), %edi
callq 0x140fd
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
testl %r12d, %r12d
cmovlel %ebx, %r12d
testl %ebp, %ebp
movl $0x0, %r13d
movq %rbp, 0x18(%rsp)
cmovgl %ebp, %r13d
cmpq %r13, %rbx
je 0x1cc01
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x1cbef
movq (%r14,%rbp,8), %rax
movsd (%rax,%rbx,8), %xmm1
movsd %xmm1, 0x20(%rsp)
movq %r15, %rdi
movl %ebp, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x2aea2
mulsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %rbp
jmp 0x1cbaa
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
jmp 0x1cb9f
movq %r15, %rdi
callq 0x2b47e
movq 0x10(%rsp), %rsi
movq (%rsi), %rcx
movslq 0x18(%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_O2/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
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 %r13d, %r13d
xorl %r12d, %r12d
testq %r15, %r15
je 0x1cc77
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1cb5f
movq %rax, %rcx
testq %r12, %r12
je 0x1cc6b
movq %rax, 0x10(%r13)
movq %r12, %rcx
movq 0x10(%r15), %r15
movq %rax, %r13
movq %rcx, %r12
jmp 0x1cc47
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
shrq $0x20, %r15
leal 0x1(%r15), %eax
movl %eax, 0x4(%rsp)
sarq $0x20, %rdi
movq %rdi, 0x8(%rsp)
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x1cd2c
movq %r13, 0x10(%rsp)
movl 0x4(%rsp), %edi
callq 0x140fd
movq %rax, %r13
xorl %eax, %eax
cmpq %rax, %r15
je 0x1ccf8
movq (%r14,%rbp,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq (%r13), %rcx
movsd %xmm0, (%rcx,%rax,8)
incq %rax
jmp 0x1ccdc
movq %rbx, %rdi
callq 0x2b47e
movq (%r13), %rcx
movq 0x8(%rsp), %rdx
movl %eax, (%rcx,%rdx,8)
movq %r13, %rax
testq %r12, %r12
je 0x1cd20
movq 0x10(%rsp), %rax
movq %r13, 0x10(%rax)
movq %r12, %rax
movq 0x10(%rbx), %rbx
incq %rbp
movq %rax, %r12
jmp 0x1ccc4
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39225
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x392ac
movq %rax, %r12
movq %rdx, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
movq %rbx, (%rsp)
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3933d
movq %rax, %r14
movq %rdx, %r15
movq %r12, %rdi
movq %r13, %rsi
callq 0x392ac
movq %rax, %rbp
movq %rdx, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3929f
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x3933d
movq (%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
movq %rbp, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3929f
// File: /workspace/github_c_makefile_star2_O2/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 0x39225
movq %rdx, %rcx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %rax, %rdx
callq 0x3933d
movq %rax, %r14
movq %rdx, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3929f
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39225
movq %rax, %r14
movq %rdx, %r15
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3929f
movq %r12, %rdi
movl %ebx, %esi
callq 0x39e8c
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r12, %rdi
callq 0x34ff7
movsd 0x78e66(%rip), %xmm0    # 0x95d20
movq %rbx, %rdi
callq 0x39de5
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3933d
movq %rax, %r12
movq %rdx, %r13
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3929f
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
movq %r12, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x1cc89
movq %rax, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3929f
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_O2/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 0x1cf57
jnp 0x1cf47
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 0x39225
movq %rax, %r13
movq %rdx, %rbp
movq %r12, %rdi
movq %r15, %rsi
callq 0x3929f
movq %r14, %rdi
callq 0x34ff7
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1cc89
movq %rax, %rbx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3929f
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_O2/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, %r12
leaq 0x10(%rsp), %r13
movq %rdi, (%r13)
movq %rsi, 0x8(%r13)
movl %r12d, %esi
callq 0x380d3
movq %rax, %rbx
movq %rdx, %r14
movq %r13, %rdi
callq 0x39e49
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x39ec4
movl %r12d, %eax
imull %r12d, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x39f86
movq %rax, %r15
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x3a199
movsd 0x8(%rsp), %xmm2
movq %rax, %r13
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
movl %r12d, %edx
movsd 0x78cd1(%rip), %xmm0    # 0x95d20
cmpq %rcx, %rax
je 0x1d093
movq 0x18(%rsp), %rsi
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x1d08e
movsd (%r13,%rax,8), %xmm1
addsd (%r15,%rdi,8), %xmm1
subsd %xmm2, %xmm1
movq (%rsi,%rax,8), %r8
subsd (%r8,%rdi,8), %xmm1
mulsd %xmm0, %xmm1
movq (%r14,%rax,8), %r8
movsd %xmm1, (%r8,%rdi,8)
incq %rdi
jmp 0x1d05b
incq %rax
jmp 0x1d04f
movq %r15, %rdi
callq 0x34ff7
movq %r13, %rdi
callq 0x34ff7
movq %rbx, %rax
movq %r14, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x78, %rsp
movl %r9d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
movq %r8, 0x28(%rsp)
movq %r8, %rsi
movl %r9d, %edx
callq 0x3a173
cvttsd2si %xmm0, %edi
movl %edi, %esi
callq 0x380d3
movq %rax, 0x30(%rsp)
movq %rdx, 0x18(%rsp)
movslq %ebp, %rax
movq %rax, 0x20(%rsp)
xorl %edx, %edx
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
movq %rax, 0x40(%rsp)
movl %r14d, %eax
movq %rax, 0x58(%rsp)
movq %rbx, 0x38(%rsp)
movq %rbx, %r14
xorl %esi, %esi
cmpq 0x40(%rsp), %rdx
je 0x1d268
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%rdx,8), %xmm0
ucomisd 0x783d1(%rip), %xmm0    # 0x95520
jne 0x1d25c
jp 0x1d25c
movq %rdx, 0x48(%rsp)
movl %esi, 0x14(%rsp)
movslq %esi, %rax
movq %rax, 0x50(%rsp)
xorl %ebx, %ebx
xorl %edx, %edx
movq 0x38(%rsp), %r13
cmpq 0x58(%rsp), %rbx
je 0x1d251
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%rbx,8), %xmm0
ucomisd 0x78385(%rip), %xmm0    # 0x95520
jne 0x1d245
jp 0x1d245
movq %rdx, 0x60(%rsp)
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
movl 0x1c0(%r12), %eax
decl %eax
cmpl %eax, %ebp
jge 0x1d228
movq %r15, %rdi
movl %ebp, %esi
movsd %xmm0, 0x70(%rsp)
callq 0x2aea2
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x2aea2
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x2aea2
movsd %xmm0, 0x68(%rsp)
movq %r13, %rdi
movl %ebp, %esi
callq 0x2aea2
movsd 0x68(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x70(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm0
incl %ebp
jmp 0x1d1b2
movq 0x18(%rsp), %rax
movq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x60(%rsp), %rdx
movslq %edx, %rdx
movsd %xmm0, (%rax,%rdx,8)
incl %edx
incq %rbx
movq 0x10(%r13), %r13
jmp 0x1d175
movl 0x14(%rsp), %esi
incl %esi
movq 0x48(%rsp), %rdx
incq %rdx
movq 0x10(%r14), %r14
jmp 0x1d129
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rdx
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x20(%rsp)
movq %rdx, %r13
shrq $0x20, %r13
movq %rdx, 0x30(%rsp)
movl %edx, %edi
movl %r13d, %esi
callq 0x380d3
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
movq %rdx, %r12
movq %r14, 0x28(%rsp)
testq %r14, %r14
je 0x1d390
movq 0x20(%rsp), %rdi
movq %r14, 0x38(%rsp)
movq %r14, %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %rbx, %r8
movl %ebp, %r9d
callq 0x1d0b7
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3a9f7
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x39ec4
movsd %xmm0, 0x40(%rsp)
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq %r15, %r13
je 0x1d370
movq (%rbx,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd 0x789e1(%rip), %xmm0    # 0x95d18
jne 0x1d33b
jnp 0x1d362
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
callq 0x3a173
divsd 0x40(%rsp), %xmm0
movq (%r12,%rbp,8), %rax
movsd %xmm0, (%rax,%r15,8)
incl %r14d
jmp 0x1d36b
movq (%r12,%rbp,8), %rax
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x1d320
incq %rbp
movq 0x38(%rsp), %r14
movq 0x10(%r14), %r14
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3929f
jmp 0x1d2c6
movq 0x18(%rsp), %rax
movq %r12, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rbp
movq %rdi, %r14
shrq $0x20, %r14
movl %r14d, %esi
callq 0x380d3
movq %rax, 0x8(%rsp)
movq %rdx, %r12
xorl %r13d, %r13d
testl %r14d, %r14d
cmovlel %r13d, %r14d
testl %ebp, %ebp
movl $0x0, %eax
cmovgl %ebp, %eax
movq %rax, 0x10(%rsp)
movl %ebp, %r15d
cmpq 0x10(%rsp), %r13
je 0x1d44f
xorl %ebp, %ebp
cmpq %r14, %rbp
je 0x1d44a
movl %r13d, %edi
movl %ebp, %esi
callq 0x352f4
cvtsi2sd %eax, %xmm0
movq (%rbx,%r13,8), %rax
subsd (%rax,%rbp,8), %xmm0
movq (%rbx,%rbp,8), %rax
subsd (%rax,%r13,8), %xmm0
xorl %eax, %eax
cmpq %rax, %r15
je 0x1d43c
movq (%rbx,%rax,8), %rcx
movsd (%rcx,%r13,8), %xmm1
mulsd (%rcx,%rbp,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1d41f
movq (%r12,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x1d3f7
incq %r13
jmp 0x1d3ee
movq 0x8(%rsp), %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq %r15, %rbx
je 0x1d4c1
movsd (%r14,%r15,8), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x1d4e1
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm1
addsd (%r14,%r15,8), %xmm1
incq %r15
jmp 0x1d48c
movapd %xmm1, %xmm0
callq 0x1d4e1
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_O2/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 0x7a4ca(%rip), %xmm0    # 0x979c0
movaps %xmm0, 0x10(%rsp)
movaps 0x7a4ce(%rip), %xmm0    # 0x979d0
movaps %xmm0, 0x20(%rsp)
movaps 0x7a4d2(%rip), %xmm0    # 0x979e0
movaps %xmm0, 0x30(%rsp)
movsd 0x7a515(%rip), %xmm0    # 0x97a30
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
callq 0x4160
movsd 0x8(%rsp), %xmm5
movapd %xmm0, %xmm1
movsd 0x7a4fd(%rip), %xmm0    # 0x97a38
xorl %eax, %eax
movsd 0x77fdb(%rip), %xmm2    # 0x95520
movapd %xmm5, %xmm3
cmpq $0x6, %rax
je 0x1d566
movsd 0x10(%rsp,%rax,8), %xmm4
addsd %xmm2, %xmm3
divsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rax
jmp 0x1d549
movsd 0x787b2(%rip), %xmm2    # 0x95d20
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm2
movsd (%rsp), %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
mulsd 0x7a4b4(%rip), %xmm0    # 0x97a40
divsd %xmm5, %xmm0
callq 0x4160
subsd (%rsp), %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d839
jnp 0x1d99e
movapd 0x7899f(%rip), %xmm3    # 0x961e0
andpd %xmm1, %xmm3
mulsd 0x784d3(%rip), %xmm3    # 0x95d20
movsd 0x77ccb(%rip), %xmm2    # 0x95520
ucomisd 0x7a20b(%rip), %xmm3    # 0x97a68
jae 0x1d99e
ucomisd %xmm3, %xmm2
jbe 0x1d8e6
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
movsd 0x7a277(%rip), %xmm2    # 0x97af0
mulsd %xmm4, %xmm2
addsd 0x7a273(%rip), %xmm2    # 0x97af8
mulsd %xmm4, %xmm2
addsd 0x7a26f(%rip), %xmm2    # 0x97b00
mulsd %xmm4, %xmm2
addsd 0x7a26b(%rip), %xmm2    # 0x97b08
mulsd %xmm4, %xmm2
addsd 0x7a267(%rip), %xmm2    # 0x97b10
mulsd %xmm4, %xmm2
addsd 0x7a263(%rip), %xmm2    # 0x97b18
mulsd %xmm4, %xmm2
addsd 0x7a25f(%rip), %xmm2    # 0x97b20
mulsd %xmm4, %xmm2
addsd 0x7a25b(%rip), %xmm2    # 0x97b28
mulsd %xmm4, %xmm2
addsd 0x7a257(%rip), %xmm2    # 0x97b30
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm2
jmp 0x1d99e
addsd 0x7a182(%rip), %xmm3    # 0x97a70
movsd 0x7a182(%rip), %xmm2    # 0x97a78
mulsd %xmm3, %xmm2
addsd 0x7a17e(%rip), %xmm2    # 0x97a80
mulsd %xmm3, %xmm2
addsd 0x7a17a(%rip), %xmm2    # 0x97a88
mulsd %xmm3, %xmm2
addsd 0x7a176(%rip), %xmm2    # 0x97a90
mulsd %xmm3, %xmm2
addsd 0x7a172(%rip), %xmm2    # 0x97a98
mulsd %xmm3, %xmm2
addsd 0x7a16e(%rip), %xmm2    # 0x97aa0
mulsd %xmm3, %xmm2
addsd 0x7a16a(%rip), %xmm2    # 0x97aa8
mulsd %xmm3, %xmm2
addsd 0x7a166(%rip), %xmm2    # 0x97ab0
mulsd %xmm3, %xmm2
addsd 0x7a162(%rip), %xmm2    # 0x97ab8
mulsd %xmm3, %xmm2
addsd 0x7a15e(%rip), %xmm2    # 0x97ac0
mulsd %xmm3, %xmm2
addsd 0x7a15a(%rip), %xmm2    # 0x97ac8
mulsd %xmm3, %xmm2
addsd 0x7a156(%rip), %xmm2    # 0x97ad0
mulsd %xmm3, %xmm2
addsd 0x7a152(%rip), %xmm2    # 0x97ad8
mulsd %xmm3, %xmm2
addsd 0x7a14e(%rip), %xmm2    # 0x97ae0
mulsd %xmm3, %xmm2
addsd 0x7a14a(%rip), %xmm2    # 0x97ae8
movapd 0x7882a(%rip), %xmm3    # 0x961d0
xorpd %xmm2, %xmm3
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm3, %xmm0
orpd %xmm2, %xmm0
addsd 0x77b5d(%rip), %xmm0    # 0x95520
mulsd 0x78355(%rip), %xmm0    # 0x95d20
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x1da05
ucomisd 0x77b42(%rip), %xmm0    # 0x95520
jae 0x1daa8
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebx
cvtsi2sd %edi, %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
movsd %xmm0, 0x10(%rsp)
jb 0x1da12
sqrtsd %xmm0, %xmm0
jmp 0x1da25
movsd 0x7a12b(%rip), %xmm2    # 0x97b38
jmp 0x1daa8
movapd %xmm2, (%rsp)
callq 0x4300
xorpd %xmm3, %xmm3
movapd (%rsp), %xmm2
divsd %xmm0, %xmm2
movsd 0x7a107(%rip), %xmm1    # 0x97b38
movapd %xmm1, %xmm0
subsd %xmm3, %xmm0
ucomisd 0x7a0ff(%rip), %xmm0    # 0x97b40
jbe 0x1daa3
movsd %xmm1, 0x18(%rsp)
movapd %xmm3, 0x20(%rsp)
movl %ebx, %edi
movapd %xmm2, %xmm0
movapd %xmm2, (%rsp)
callq 0x1d59f
movapd (%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
ucomisd %xmm0, %xmm3
movapd %xmm2, %xmm1
ja 0x1da7a
movsd 0x18(%rsp), %xmm1
cmpltsd %xmm3, %xmm0
movapd 0x20(%rsp), %xmm3
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm0, %xmm3
movapd %xmm3, %xmm2
addsd %xmm1, %xmm2
mulsd 0x7827f(%rip), %xmm2    # 0x95d20
jmp 0x1da31
addq $0x30, %rsp
popq %rbx
movapd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
movsd 0x77a5d(%rip), %xmm0    # 0x95520
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
leaq 0xafd9e(%rip), %r12     # 0xcd870
movq (%r12), %rax
movslq 0x1c0(%rax), %rsi
decq %rsi
cmpq %rsi, %r15
jge 0x1db16
movq %r14, %rdi
movl %r15d, %esi
callq 0x2aea2
movsd (%rbx,%r15,8), %xmm1
addsd 0x782b2(%rip), %xmm1    # 0x95db0
callq 0x42f0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r15
jmp 0x1dad2
movq %rbx, %rdi
callq 0x1d468
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x1de38
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movapd %xmm0, %xmm2
ucomisd 0x7771e(%rip), %xmm0    # 0x95520
jae 0x1de32
movl %esi, %ebp
movl %edi, %ebx
cmpl %esi, %edi
setne %al
cmpl $0x9c5, %edi            # imm = 0x9C5
setl %cl
orb %al, %cl
jne 0x1de3d
cvtsi2sd %ebx, %xmm0
movsd 0x77fca(%rip), %xmm1    # 0x95df0
divsd %xmm0, %xmm1
addsd 0x776ee(%rip), %xmm1    # 0x95520
addq $0x38, %rsp
popq %rbx
popq %rbp
movapd %xmm1, %xmm0
retq
movsd 0x776db(%rip), %xmm1    # 0x95520
divsd %xmm2, %xmm1
xorpd %xmm3, %xmm3
movsd 0x79d03(%rip), %xmm4    # 0x97b58
movsd %xmm2, (%rsp)
movapd %xmm4, %xmm0
subsd %xmm3, %xmm0
andpd 0x78376(%rip), %xmm0    # 0x961e0
ucomisd 0x79cce(%rip), %xmm0    # 0x97b40
jbe 0x1de32
movapd %xmm4, 0x10(%rsp)
movapd %xmm1, %xmm0
movl %ebx, %edi
movl %ebp, %esi
movapd %xmm1, 0x20(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x1db37
movsd 0x8(%rsp), %xmm3
movsd (%rsp), %xmm2
movapd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm2
ja 0x1deae
movapd %xmm1, %xmm3
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm1
andnpd 0x10(%rsp), %xmm0
orpd %xmm1, %xmm0
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
mulsd 0x77e4f(%rip), %xmm1    # 0x95d20
movapd %xmm0, %xmm4
jmp 0x1de5a
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/distributions.c
// Function: normal
double normal(double x,int upper)
{
 double Alnorm,ltone=7.0,utzero=18.66,con=1.28,z,y;
 z=x;
 if (z<0)
  {
   upper=1-upper;
   z=-z;
  }
 if ((z <= ltone) || ((upper) && (z >= utzero)))
  {
   y=0.5*z*z;
   if (z>con)
     Alnorm=0.398942280385*exp(-y)/(z-3.8052*0.00000001+1.00000615302/(z+3.98064794*0.0001+1.98615381364/(z-0.151679116635+5.29330324926/(z+4.8385912808-15.1508972451/(z+0.742380924027+30.789933034/(z+3.99019417011))))));
   else
     Alnorm=0.5-z*(0.398942280444-0.399903438504*y/(y+5.75885480458-29.8213557808/(y+2.62433121679+48.6959930692/(y+5.92885724438))));
  }
 else
   Alnorm=0;
 if (!upper)
   return 1-Alnorm;
 else
   return Alnorm;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rbx
subl %edi, %ebx
movapd 0x782a1(%rip), %xmm5    # 0x961d0
xorpd %xmm0, %xmm5
ucomisd %xmm0, %xmm5
cmovbel %edi, %ebx
maxsd %xmm0, %xmm5
movsd 0x79c2a(%rip), %xmm0    # 0x97b70
ucomisd %xmm5, %xmm0
jae 0x1df68
testl %ebx, %ebx
sete %al
ucomisd 0x79c1f(%rip), %xmm5    # 0x97b78
setb %cl
orb %al, %cl
xorpd %xmm0, %xmm0
jne 0x1e0ab
movsd 0x77db0(%rip), %xmm0    # 0x95d20
mulsd %xmm5, %xmm0
mulsd %xmm5, %xmm0
ucomisd 0x79c00(%rip), %xmm5    # 0x97b80
jbe 0x1e043
xorpd 0x78242(%rip), %xmm0    # 0x961d0
movapd %xmm5, (%rsp)
callq 0x4060
mulsd 0x79c20(%rip), %xmm0    # 0x97bc0
movsd 0x79c20(%rip), %xmm1    # 0x97bc8
movapd (%rsp), %xmm6
addsd %xmm6, %xmm1
movsd 0x79c17(%rip), %xmm2    # 0x97bd0
addsd %xmm6, %xmm2
movsd 0x79c13(%rip), %xmm3    # 0x97bd8
addsd %xmm6, %xmm3
movsd 0x79c0f(%rip), %xmm4    # 0x97be0
addsd %xmm6, %xmm4
movsd 0x79c0b(%rip), %xmm5    # 0x97be8
addsd %xmm6, %xmm5
addsd 0x79c07(%rip), %xmm6    # 0x97bf0
movapd %xmm6, %xmm7
movsd 0x79c03(%rip), %xmm6    # 0x97bf8
divsd %xmm7, %xmm6
addsd %xmm5, %xmm6
movsd 0x79bfb(%rip), %xmm5    # 0x97c00
divsd %xmm6, %xmm5
addsd %xmm4, %xmm5
movsd 0x79bf3(%rip), %xmm4    # 0x97c08
divsd %xmm5, %xmm4
addsd %xmm3, %xmm4
movsd 0x79beb(%rip), %xmm3    # 0x97c10
divsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd 0x79be3(%rip), %xmm2    # 0x97c18
divsd %xmm3, %xmm2
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0x1e0ab
movsd 0x79b3d(%rip), %xmm1    # 0x97b88
mulsd %xmm0, %xmm1
movsd 0x79b39(%rip), %xmm2    # 0x97b90
addsd %xmm0, %xmm2
movsd 0x79b35(%rip), %xmm3    # 0x97b98
addsd %xmm0, %xmm3
addsd 0x79b31(%rip), %xmm0    # 0x97ba0
movsd 0x79b31(%rip), %xmm4    # 0x97ba8
divsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x79b29(%rip), %xmm0    # 0x97bb0
divsd %xmm4, %xmm0
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
addsd 0x79b1d(%rip), %xmm1    # 0x97bb8
mulsd %xmm1, %xmm5
movsd 0x77c79(%rip), %xmm0    # 0x95d20
subsd %xmm5, %xmm0
testl %ebx, %ebx
jne 0x1e0bf
movsd 0x77469(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/distributions.c
// Function: qtrng0
double qtrng0(double p, double v, double r)
{
 double q,t,vmax=12000,c1=0.8843,c2=0.2368,c3=1.214,c4=1.208,c5=1.4142;
 t=z_inverse(0.5+0.5*p);
 if (v<vmax)
   t=t+(t*t*t+t)/v/4;
 q=c1-c2*t;
 if (v<vmax)
   q=q-c3/v+c4*t/v;
 return t*(q*log(r-1)+c5);
}

// Assembly:
subq $0x28, %rsp
movsd %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movsd 0x776f1(%rip), %xmm1    # 0x95d20
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
callq 0x1e700
movapd 0x10(%rsp), %xmm3
movsd 0x795ee(%rip), %xmm1    # 0x97c38
ucomisd %xmm3, %xmm1
jbe 0x1e6b8
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
divsd %xmm3, %xmm1
mulsd 0x776a4(%rip), %xmm1    # 0x95d10
addsd %xmm1, %xmm0
movsd 0x79600(%rip), %xmm2    # 0x97c78
mulsd %xmm0, %xmm2
addsd 0x795fc(%rip), %xmm2    # 0x97c80
movsd 0x795fc(%rip), %xmm1    # 0x97c88
movsd %xmm0, 0x8(%rsp)
mulsd %xmm0, %xmm1
movapd 0x79362(%rip), %xmm0    # 0x97a00
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm0
subsd %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
jmp 0x1e6ce
movsd %xmm0, 0x8(%rsp)
mulsd 0x795b2(%rip), %xmm0    # 0x97c78
addsd 0x795b2(%rip), %xmm0    # 0x97c80
movapd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
addsd 0x776ce(%rip), %xmm0    # 0x95db0
callq 0x4160
mulsd 0x10(%rsp), %xmm0
addsd 0x7959b(%rip), %xmm0    # 0x97c90
mulsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/distributions.c
// Function: z_inverse
double z_inverse(double p)
{/*Returns the critical value given the probability*/
 double  minz = -Z_MAX;    /* minimum of range of z */
 double  maxz = Z_MAX;     /* maximum of range of z */
 double  zval = 0.0;       /* computed/returned z value */
 double  pval;     /* prob (z) function, pval := poz (zval) */
 if (p <= 0.0 || p >= 1.0)
   return (0.0);
 while (maxz - minz > Z_EPSILON)
  {
   pval = z_normal (zval);
   if (pval > p)
     maxz = zval;
   else
     minz = zval;
   zval = (maxz + minz) * 0.5;
  }
 return (zval);
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0x1e7b2
ucomisd 0x76e06(%rip), %xmm1    # 0x95520
jae 0x1e7b2
subq $0x38, %rsp
movsd %xmm1, (%rsp)
xorpd %xmm0, %xmm0
movsd 0x79563(%rip), %xmm2    # 0x97c98
movsd 0x79563(%rip), %xmm4    # 0x97ca0
movapd %xmm2, %xmm1
subsd %xmm4, %xmm1
ucomisd 0x793f3(%rip), %xmm1    # 0x97b40
jbe 0x1e7ae
movsd %xmm2, 0x8(%rsp)
movapd %xmm4, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
callq 0x1d821
movapd 0x20(%rsp), %xmm3
movsd (%rsp), %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm3, %xmm1
ja 0x1e781
movsd 0x8(%rsp), %xmm1
cmpltsd %xmm0, %xmm2
movapd 0x10(%rsp), %xmm4
andpd %xmm2, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm2, %xmm4
movapd %xmm4, %xmm0
addsd %xmm1, %xmm0
mulsd 0x77578(%rip), %xmm0    # 0x95d20
movapd %xmm1, %xmm2
jmp 0x1e73d
addq $0x38, %rsp
retq