LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: generate_tests
int generate_tests(char **files, int filecount)
{
 int *counts, **subsets, res, i, j;
 FILE *myfile;
 if (filecount < 2)
   return 0;
 myfile = fopen(files[0], "w");
 if (!myfile)
   return -1;
 subsets = generate_subsets(filecount - 1, &res, &counts);
 for (i = 0; i < res; i++)
   if (counts[i] > 1)
    {
     fprintf(myfile, "multitest ");
     for (j = 0; j < counts[i]; j++)
       fprintf(myfile, "%s ", files[subsets[i][j] + 1]);
     fprintf(myfile, "\n");
    }
 for (i = 0; i < res; i++)
   if (counts[i] > 0)
     safe_free(subsets[i]);
 safe_free(subsets);
 safe_free(counts);
 fclose(myfile);
 return 1;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x8bf41
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rdi
leaq 0x1ca75(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x8bf2e
movq %rax, %rbx
decl %ebp
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %rdx
movl %ebp, %edi
movq %r12, %rsi
callq 0x389b4
movq %rax, %r14
cmpl $0x0, (%r12)
jle 0x8bee1
leaq 0x21f4b(%rip), %r13     # 0xaddb3
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax,%rbp,4)
jl 0x8bed4
movl $0xa, %esi
movl $0x1, %edx
leaq 0x22849(%rip), %rdi     # 0xae6cf
movq %rbx, %rcx
callq 0x42c0
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax,%rbp,4)
jle 0x8bec7
xorl %r12d, %r12d
movq (%r14,%rbp,8), %rax
movslq (%rax,%r12,4), %rax
movq 0x8(%r15,%rax,8), %rdx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x42e0
incq %r12
movq 0x10(%rsp), %rax
movslq (%rax,%rbp,4), %rax
cmpq %rax, %r12
jl 0x8be9c
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
incq %rbp
movslq 0xc(%rsp), %rax
cmpq %rax, %rbp
jl 0x8be6a
cmpl $0x0, 0xc(%rsp)
jle 0x8bf0d
xorl %r15d, %r15d
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x8bf00
movq (%r14,%r15,8), %rdi
callq 0x39194
incq %r15
movslq 0xc(%rsp), %rax
cmpq %rax, %r15
jl 0x8beeb
movq %r14, %rdi
callq 0x39194
movq 0x10(%rsp), %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x42a0
movl $0x1, %eax
jmp 0x8bf33
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: file_whiskers
void file_whiskers(char* file, double p25, double p75, double* swhisker, double* lwhisker)
{
 /*Last Changed 29.01.2007*/
 FILE* myfile;
 int count, i;
 double lowerbound, upperbound, smallest, largest, observation;
 smallest = p25;
 largest = p75;
 lowerbound = p25 - (p75 - p25) * 1.5;
 upperbound = p75 + (p75 - p25) * 1.5;
 count = file_length(file);
 if ((myfile = fopen(file, "r")) == NULL)
  {
   printf(m1274, file);
   return;
  }
 for (i = 0; i < count; i++)
  {
   fscanf(myfile, "%lf", &observation);
   if (observation <= smallest && observation >= lowerbound)
     smallest = observation;
   if (observation >= largest && observation <= upperbound)
     largest = observation;
  } 
 *swhisker = smallest;
 *lwhisker = largest;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movapd %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdi, %r12
callq 0x37e22
movl %eax, %ebp
leaq 0x1c0ef(%rip), %rsi     # 0xa888f
movq %r12, %rdi
callq 0x40f0
testq %rax, %rax
je 0x8c8ad
testl %ebp, %ebp
jle 0x8c8cc
movq %rax, %r15
movapd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm0
movapd (%rsp), %xmm2
subsd %xmm2, %xmm0
mulsd 0x16609(%rip), %xmm0    # 0xa2de0
movapd %xmm2, %xmm3
subsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x1a41a(%rip), %r12     # 0xa6c10
leaq 0x38(%rsp), %r13
movapd %xmm1, %xmm5
movapd %xmm2, (%rsp)
movapd %xmm1, 0x10(%rsp)
movapd %xmm5, 0x40(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
movapd 0x40(%rsp), %xmm5
movsd 0x38(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
cmpnlesd %xmm0, %xmm1
movapd %xmm1, %xmm2
movapd (%rsp), %xmm4
andpd %xmm4, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movapd %xmm0, %xmm2
cmpnlesd 0x30(%rsp), %xmm2
movapd %xmm2, %xmm3
andnpd %xmm0, %xmm2
cmpnlesd %xmm0, %xmm5
cmpnlesd %xmm4, %xmm0
movapd %xmm4, %xmm6
movapd %xmm0, %xmm4
andnpd %xmm1, %xmm4
andpd %xmm6, %xmm0
orpd %xmm4, %xmm0
movapd 0x10(%rsp), %xmm4
andpd %xmm4, %xmm3
orpd %xmm3, %xmm2
movapd %xmm5, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm4, %xmm5
orpd %xmm1, %xmm5
movapd %xmm5, %xmm1
movapd %xmm0, %xmm2
decl %ebp
jne 0x8c7ff
jmp 0x8c8d7
leaq 0x16956(%rip), %rdi     # 0xa320a
movq %r12, %rsi
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
movapd (%rsp), %xmm0
movapd 0x10(%rsp), %xmm5
movsd %xmm0, (%r14)
movsd %xmm5, (%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: file_variance
double file_variance(char **files,int filecount)
{
/*Last Changed 27.04.2002*/
 FILE *myfile;
 double mean = file_mean(files, filecount), sum = 0, temp;
 int counts,i,total=0,j;
 for (i=0;i<filecount;i++)
  {
   counts = file_length(files[i]);
   if ((myfile = fopen(files[i],"r")) == NULL)
    {
     printf(m1274, files[i]);
     return 0;
    }
   for (j=0;j<counts;j++)
    {
     fscanf(myfile,"%lf",&temp);
     sum+=(temp-mean)*(temp-mean);
    }
   total+=counts;
   fclose(myfile);
  }
 return sqrt(sum/(total-1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, 0x18(%rsp)
callq 0x8bbed
testl %ebp, %ebp
jle 0x8cbab
movsd %xmm0, 0x28(%rsp)
movl %ebp, %eax
movq %rax, 0x20(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x1a127(%rip), %r15     # 0xa6c10
leaq 0x30(%rsp), %r12
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x18(%rsp), %r13
movq (%r13,%rbx,8), %rdi
callq 0x37e22
movl %eax, %r14d
movq (%r13,%rbx,8), %rdi
leaq 0x1bd7f(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x8cbca
movq %rax, %r13
movl %ebp, 0x14(%rsp)
movl %r14d, %ebp
testl %r14d, %r14d
movsd 0x8(%rsp), %xmm0
jle 0x8cb73
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
movsd 0x30(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
decl %ebp
jne 0x8cb33
movsd %xmm0, 0x8(%rsp)
movl 0x14(%rsp), %ebp
addl %r14d, %ebp
movq %r13, %rdi
callq 0x42a0
incq %rbx
cmpq 0x20(%rsp), %rbx
jne 0x8caf2
decl %ebp
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
jmp 0x8cbb3
movsd 0x218e5(%rip), %xmm0    # 0xae498
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8cbc3
sqrtsd %xmm0, %xmm0
jmp 0x8cbe5
callq 0x4300
jmp 0x8cbe5
movq 0x18(%rsp), %rax
movq (%rax,%rbx,8), %rsi
leaq 0x16630(%rip), %rdi     # 0xa320a
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: generate_statistical_data
void generate_statistical_data(char* filename, int datacount, int zeroonecount, double errorrate)
{
 FILE* myfile;
 int i, j, zeros, x;
 char pst[READLINELENGTH];
 myfile = fopen(filename,"w");
 if (!myfile)
   return;
 for (i = 0; i<datacount; i++)
  {
   zeros = 0;
   for (j = 0; j<zeroonecount; j++)
    {
     x = myrand()*myrand();
     if (((x%10000)/10000.0)<errorrate)
       zeros++;
    }
   set_precision(pst, NULL, "\n");
   fprintf(myfile, pst, zeros / (zeroonecount + 0.0));
  }
 fclose(myfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movsd %xmm0, 0x18(%rsp)
movl %edx, %r12d
movl %esi, %ebx
leaq 0x1bc8a(%rip), %rsi     # 0xa88a1
callq 0x40f0
movq %rax, (%rsp)
testq %rax, %rax
je 0x8cd01
testl %ebx, %ebx
jle 0x8ccf8
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x8ccb2
movl %ebx, %r14d
xorl %ebp, %ebp
movl %r12d, %ebx
xorl %eax, %eax
callq 0x39f18
movl %eax, %r13d
xorl %eax, %eax
callq 0x39f18
imull %r13d, %eax
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x19ee7(%rip), %xmm0    # 0xa6b78
xorl %eax, %eax
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addl %eax, %ebp
decl %ebx
jne 0x8cc4f
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movl %r14d, %ebx
jmp 0x8ccb6
xorpd %xmm0, %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
leaq 0x19498(%rip), %rdx     # 0xa616b
callq 0x39529
movq (%rsp), %rdi
movq %r14, %rsi
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
incl %r15d
cmpl %ebx, %r15d
jne 0x8cc42
movq (%rsp), %rdi
callq 0x42a0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: produce_normal_value
double produce_normal_value(double mean, double stdev)
{
 /*Last Changed 08.04.2004*/
 int i;
 double x = 0;
 for (i = 0; i < 12; i++)
   x += produce_random_value(0, 1);
 x -= 6;
 return mean + x * stdev;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
movl $0xc, %ebx
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x157e1(%rip), %xmm1    # 0xa2520
callq 0x39f62
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
decl %ebx
jne 0x8cd2d
addsd 0x17f02(%rip), %xmm0    # 0xa4c68
mulsd 0x10(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: produce_normal_distribution
void produce_normal_distribution(char* filename, int N, double mean, double stdev)
{
 /*Last Changed 08.04.2004*/
 FILE* myfile;
 int i;
 char pst[READLINELENGTH];
 myfile = fopen(filename, "w");
 if (!myfile)
   return;
 for (i = 0; i < N; i++)
  {
   set_precision(pst, NULL, "\n");
   fprintf(myfile, pst, produce_normal_value(mean, stdev));
  }
 fclose(myfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
leaq 0x1bb03(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x8ce32
movq %rax, %r14
testl %ebx, %ebx
jle 0x8ce2a
xorl %r13d, %r13d
leaq 0x193ae(%rip), %r15     # 0xa616b
leaq 0x20(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x39529
movl $0xc, %ebp
xorpd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd 0x15736(%rip), %xmm1    # 0xa2520
callq 0x39f62
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
decl %ebp
jne 0x8cdd8
addsd 0x17e63(%rip), %xmm1    # 0xa4c68
mulsd 0x10(%rsp), %xmm1
addsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movq %r12, %rsi
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0x42e0
incl %r13d
cmpl %ebx, %r13d
jne 0x8cdc2
movq %r14, %rdi
callq 0x42a0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: bootstrap
void bootstrap(char* infile, char* outfile)
{
 /*Last Changed 08.04.2004*/
 FILE* inputfile, *outputfile;
 double *input;
 char pst[READLINELENGTH];
 int len = file_length(infile), i, index;
 inputfile = fopen(infile, "r");
 if (!inputfile)
   return;
 input = safemalloc(len * sizeof(double), "bootstrap", 5);
 for (i = 0; i < len; i++)
   fscanf(inputfile, "%lf", &(input[i]));
 fclose(inputfile);
 outputfile = fopen(outfile, "w");
 if (!outputfile)
   return;
 for (i = 0; i < len; i++)
  {
   index = myrand() % len;
   set_precision(pst, NULL, "\n");
   fprintf(outputfile, pst, input[index]);
  }
 fclose(outputfile);
 safe_free(input);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %rsi, %r15
movq %rdi, %r14
callq 0x37e22
movl %eax, %ebx
leaq 0x1ba26(%rip), %rsi     # 0xa888f
movq %r14, %rdi
callq 0x40f0
testq %rax, %rax
je 0x8cf46
movq %rax, %r12
movslq %ebx, %rdi
shlq $0x3, %rdi
leaq 0x1bd3b(%rip), %rsi     # 0xa8bc6
movl $0x5, %edx
callq 0x390f5
movq %rax, 0x8(%rsp)
movl %ebx, %r14d
testl %ebx, %ebx
jle 0x8cec9
movl %r14d, %ebx
leaq 0x19d65(%rip), %r13     # 0xa6c10
movq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbp
decq %rbx
jne 0x8ceb0
movq %r12, %rdi
callq 0x42a0
leaq 0x1b9c9(%rip), %rsi     # 0xa88a1
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x8cf46
movq %rax, %r15
movl %r14d, %ebp
testl %r14d, %r14d
movq 0x8(%rsp), %r12
jle 0x8cf36
leaq 0x10(%rsp), %r13
movl %ebp, %ebx
xorl %eax, %eax
callq 0x39f18
cltd
idivl %ebp
movl %edx, %ebp
movq %r13, %rdi
xorl %esi, %esi
leaq 0x19257(%rip), %rdx     # 0xa616b
callq 0x39529
movslq %ebp, %rax
movl %r14d, %ebp
movsd (%r12,%rax,8), %xmm0
movq %r15, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
decl %ebx
jne 0x8cefc
movq %r15, %rdi
callq 0x42a0
movq %r12, %rdi
callq 0x39194
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: multiple_tests
void multiple_tests(double (*algorithm)(char** files), char** params, int paramcount)
{
/*Last Changed 30.04.2002*/
 double tmp;
 if (paramcount > 0)
   if (paramcount > 1)
    {
     tmp = algorithm(params);
     set_default_variable("out2",tmp);
     if (tmp >= 1 - get_parameter_f("confidencelevel"))
      {
       if (get_parameter_o("displayresulton"))
         printf(m1033);
       set_default_variable("out1",1.0);
      }
     else
      {
       if (get_parameter_o("displayresulton"))
         printf(m1034);
       set_default_variable("out1",0.0);
      }
    }
   else
     printf(m1035);
 else
   printf(m1036);
}

// Assembly:
subq $0x18, %rsp
testl %edx, %edx
jle 0x8cf6e
cmpl $0x1, %edx
jne 0x8cf7e
leaq 0x21849(%rip), %rdi     # 0xae7b5
jmp 0x8cf75
leaq 0x2181a(%rip), %rdi     # 0xae78f
addq $0x18, %rsp
jmp 0x4090
movq %rdi, %rax
movq %rsi, %rdi
callq *%rax
movsd %xmm0, 0x10(%rsp)
leaq 0x1902b(%rip), %rdi     # 0xa5fbe
callq 0x3403a
leaq 0x15989(%rip), %rdi     # 0xa2928
callq 0x534b6
movsd 0x15574(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x16664(%rip), %rdi     # 0xa3621
callq 0x536e7
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jae 0x8cfed
testl %eax, %eax
je 0x8cfe0
leaq 0x21891(%rip), %rdi     # 0xae86c
callq 0x4090
leaq 0x18fd1(%rip), %rdi     # 0xa5fb8
xorpd %xmm0, %xmm0
jmp 0x8d00c
testl %eax, %eax
je 0x8cffd
leaq 0x217e5(%rip), %rdi     # 0xae7dd
callq 0x4090
leaq 0x18fb4(%rip), %rdi     # 0xa5fb8
movsd 0x15514(%rip), %xmm0    # 0xa2520
addq $0x18, %rsp
jmp 0x3403a
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: binary_comparison
void binary_comparison(int (*algorithm)(char** files,int *which,double confidence,double *real_confidence), char** params, int paramcount)
{
 int who;
 double conf = 0.0;
 if (paramcount >= 2)
   if (!(algorithm(params, &who, 1 - get_parameter_f("confidencelevel"), &conf)))
    {
     if (get_parameter_o("displayresulton"))
      {
       if (get_parameter_i("tailed") == 2)
         printf(m1034);
       else
         printf(m1111);
      }
     set_default_variable("out1", 0.0);
    }
   else
    {
     if (who == 1)
      {
       if (get_parameter_o("displayresulton"))
         printf(m1045);
      }
     else
       if (get_parameter_o("displayresulton"))
         if (get_parameter_i("tailed") == 2)
           printf(m1046);
     if (get_parameter_i("tailed") == 1)      
       set_default_variable("out1", 1.0);
     else
       set_default_variable("out1", who + 0.0);
    }
 else
   printf(m1047);
 set_default_variable("out2", conf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq $0x0, 0x10(%rsp)
cmpl $0x2, %edx
jl 0x8d081
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x158f1(%rip), %rdi     # 0xa2928
callq 0x534b6
movsd 0x154dc(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
leaq 0xc(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movapd %xmm1, %xmm0
callq *%rbx
testl %eax, %eax
je 0x8d092
movl 0xc(%rsp), %ebx
leaq 0x165b7(%rip), %rdi     # 0xa3621
callq 0x536e7
cmpl $0x1, %ebx
jne 0x8d0d5
testl %eax, %eax
je 0x8d0f6
leaq 0x21831(%rip), %rdi     # 0xae8b0
jmp 0x8d0f1
leaq 0x21778(%rip), %rdi     # 0xae800
callq 0x4090
jmp 0x8d12d
leaq 0x16588(%rip), %rdi     # 0xa3621
callq 0x536e7
testl %eax, %eax
je 0x8d0c8
leaq 0x1c546(%rip), %rdi     # 0xa95ef
callq 0x5341c
cmpl $0x2, %eax
leaq 0x217b4(%rip), %rax     # 0xae86c
leaq 0x21760(%rip), %rdi     # 0xae81f
cmoveq %rax, %rdi
callq 0x4090
leaq 0x18ee9(%rip), %rdi     # 0xa5fb8
xorpd %xmm0, %xmm0
jmp 0x8d128
testl %eax, %eax
je 0x8d0f6
leaq 0x1c50f(%rip), %rdi     # 0xa95ef
callq 0x5341c
cmpl $0x2, %eax
jne 0x8d0f6
leaq 0x21798(%rip), %rdi     # 0xae889
callq 0x4090
leaq 0x1c4f2(%rip), %rdi     # 0xa95ef
callq 0x5341c
cmpl $0x1, %eax
jne 0x8d118
leaq 0x18eaa(%rip), %rdi     # 0xa5fb8
movsd 0x1540a(%rip), %xmm0    # 0xa2520
jmp 0x8d128
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rsp), %xmm0
leaq 0x18e90(%rip), %rdi     # 0xa5fb8
callq 0x3403a
movsd 0x10(%rsp), %xmm0
leaq 0x18e84(%rip), %rdi     # 0xa5fbe
callq 0x3403a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: construct_posterior_matrix
matrix construct_posterior_matrix(double** posteriors, Instanceptr data)
{
 int i;
 matrix m;
 Instanceptr tmp = data;
 m = matrix_alloc(data_size(data), current_dataset->classno + 1);
 for (i = 0; i < m.row; i++)
  {
   memcpy(m.values[i], posteriors[i], current_dataset->classno * sizeof(double));
   m.values[i][current_dataset->classno] = give_classno(tmp);
   tmp = tmp->next;
  }
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2fa14
leaq 0x45399(%rip), %r13     # 0xd2870
movq (%r13), %rcx
movl 0x10(%rcx), %esi
incl %esi
movl %eax, %edi
callq 0x3c6e5
movq %rdx, %r12
movq %rax, (%rsp)
testl %eax, %eax
jle 0x8d544
movq (%rsp), %rbp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq (%r12,%r15,8), %rdi
movq (%r14,%r15,8), %rsi
movq (%r13), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x4310
movq %rbx, %rdi
callq 0x2eaca
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%r12,%r15,8), %rax
movq (%r13), %rcx
movslq 0x10(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rbx), %rbx
incq %r15
cmpq %r15, %rbp
jne 0x8d4ff
movq (%rsp), %rax
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: find_area_under_the_curve_2class
double find_area_under_the_curve_2class(matrix posteriors, int posclass, int negclass, Performance_point (*calculate_performance)(int tp, int fp, int tn, int fn))
{
 int i, number_of_points;
 double area = 0.0;
 Performance_pointptr points;
 points = find_performance_points(posteriors, &number_of_points, posclass, negclass, calculate_performance);
 for (i = 0; i < number_of_points - 1; i++)
   area += (points[i].y + points[i + 1].y) * (points[i + 1].x - points[i].x) / 2;
 safe_free(points);
 return area;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %r8, %r9
movl %ecx, %r8d
movl %edx, %ecx
leaq 0xc(%rsp), %rbx
movq %rbx, %rdx
callq 0x8d55a
movl (%rbx), %ecx
xorpd %xmm3, %xmm3
cmpl $0x2, %ecx
jl 0x8d837
decl %ecx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movsd 0x1550d(%rip), %xmm0    # 0xa2d18
movsd 0x8(%rax,%rdx), %xmm1
addsd 0x20(%rax,%rdx), %xmm1
movsd 0x18(%rax,%rdx), %xmm2
subsd (%rax,%rdx), %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm2, %xmm3
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0x8d80b
movsd %xmm3, (%rsp)
movq %rax, %rdi
callq 0x39194
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: find_area_under_the_curve_kclass
double find_area_under_the_curve_kclass(matrix posteriors, Performance_point (*calculate_performance)(int tp, int fp, int tn, int fn))
{
 double sum = 0.0;
 int i, j;
 for (i = 0; i < current_dataset->classno; i++)
   for (j = i + 1; j < current_dataset->classno; j++)
     sum += find_area_under_the_curve_2class(posteriors, i, j, calculate_performance);
 return (2 * sum) / (current_dataset->classno * (current_dataset->classno - 1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x4500c(%rip), %r13     # 0xd2870
movq (%r13), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
jle 0x8d8d6
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movl %ecx, %r12d
leal 0x1(%r12), %ebp
movq (%r13), %rax
cmpl 0x10(%rax), %ebp
movl %ebp, 0xc(%rsp)
jge 0x8d8c1
movsd %xmm1, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x8d7d2
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
incl %ebp
movq (%r13), %rax
cmpl 0x10(%rax), %ebp
jl 0x8d893
movq (%r13), %rax
movl 0x10(%rax), %eax
movl 0xc(%rsp), %ecx
cmpl %eax, %ecx
jl 0x8d87e
addsd %xmm1, %xmm1
jmp 0x8d8da
xorpd %xmm1, %xmm1
leal -0x1(%rax), %ecx
imull %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: construct_confusion_matrix_from_posteriors
Confusion_matrix construct_confusion_matrix_from_posteriors(matrix posteriors, double decision_threshold)
{
 /*!Last Changed 17.01.2009*/
 int i;
 Confusion_matrix result = {0, 0, 0, 0};
 for (i = 0; i < posteriors.row; i++)
   if (posteriors.values[i][POSITIVE_CLASS] >= decision_threshold) /*positive class assigned*/
     if (posteriors.values[i][2] == POSITIVE_CLASS)
       result.true_positives++;
     else
       result.false_positives++;
   else /*negative class assigned*/
     if (posteriors.values[i][2] == NEGATIVE_CLASS)
       result.true_negatives++;
     else
       result.false_negatives++;
 return result;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
jle 0x8d990
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movsd 0x14c00(%rip), %xmm1    # 0xa2520
movabsq $0x100000000, %r9       # imm = 0x100000000
xorpd %xmm2, %xmm2
xorl %r10d, %r10d
xorl %r8d, %r8d
xorl %edx, %edx
movq (%rsi,%r10,8), %r11
movsd (%r11), %xmm4
movsd 0x10(%r11), %xmm3
ucomisd %xmm0, %xmm4
jae 0x8d963
ucomisd %xmm1, %xmm3
jne 0x8d970
jp 0x8d970
movq %rdx, %r11
andq %rcx, %r11
movl %edx, %edx
addq %r11, %rdx
addq %r9, %rdx
jmp 0x8d97e
ucomisd %xmm2, %xmm3
jne 0x8d97c
jp 0x8d97c
incl %r8d
jmp 0x8d97e
leal 0x1(%rdx), %r11d
andq %rcx, %rdx
orq %r11, %rdx
jmp 0x8d97e
incl %eax
incq %r10
cmpq %r10, %rdi
jne 0x8d936
shlq $0x20, %r8
movl %eax, %eax
orq %r8, %rax
retq
xorl %edx, %edx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: construct_confusion_matrix_from_file
Confusion_matrixptr construct_confusion_matrix_from_file(char* posterior_file_name, double decision_threshold)
{
 /*!Last Changed 17.01.2009*/
 matrixptr posteriors;
 Confusion_matrixptr result;
 int i, numberofruns = get_parameter_i("runcount") * get_parameter_i("foldcount");
 result = safemalloc(numberofruns * sizeof(Confusion_matrix), "construct_confusion_matrix_from_file", 4);
 posteriors = read_posteriors(numberofruns, posterior_file_name);
 for (i = 0; i < numberofruns; i++)
  {
   result[i] = construct_confusion_matrix_from_posteriors(posteriors[i], decision_threshold);
   matrix_free(posteriors[i]);
  }
 safe_free(posteriors);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
leaq 0x1a29e(%rip), %rdi     # 0xa7c4d
callq 0x5341c
movl %eax, %ebx
leaq 0x1e15f(%rip), %rdi     # 0xabb1c
callq 0x5341c
movl %eax, %ebp
imull %ebx, %ebp
movslq %ebp, %r15
movq %r15, %rdi
shlq $0x4, %rdi
leaq 0x20d60(%rip), %rsi     # 0xae738
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbx
movl %r15d, %edi
movq %r14, %rsi
callq 0x858c
movq %rax, %r14
testl %r15d, %r15d
jle 0x8da36
movl %ebp, %r15d
shlq $0x4, %r15
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
movq 0x8(%r14,%r12), %rsi
movsd 0x8(%rsp), %xmm0
callq 0x8d8fe
movq %rax, (%rbx,%r12)
movq %rdx, 0x8(%rbx,%r12)
movq (%r14,%r12), %rdi
movq 0x8(%r14,%r12), %rsi
callq 0x3dbad
addq $0x10, %r12
cmpq %r12, %r15
jne 0x8da02
movq %r14, %rdi
callq 0x39194
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/structure.c
// Function: simulated_annealing_bn
bayesiangraphptr simulated_annealing_bn(char *graph_name, char *train_file, char *cv_file, char *test_file, ORDERING_TYPE ordering, double infthreshold)
{/*Last Changed 09.03.2001*/
 int i = 0, j, edgecount;
 bayesiangraphptr newnetwork;
 double **edges;
 newnetwork = (bayesiangraphptr) initial_graph_from_data(graph_name, train_file, cv_file, test_file);
 if (!newnetwork)
   return NULL;
 newnetwork->independence = zero_independence_test(newnetwork);
 newnetwork->one_independence = one_independence_test(newnetwork);
 edges = find_edges(newnetwork, infthreshold, &edgecount);
 switch (ordering)
  {
   case ORDERING_RANDOM  :random_ordering(newnetwork);
                          break;
   case ORDERING_STATE   :state_ordering(newnetwork);
                          break;
   case ORDERING_MINTABLE:min_table_ordering(newnetwork, edges, edgecount);
                          break;
   case ORDERING_ALARM   :alarm_ordering(newnetwork);
                          break;
   default               :printf(m1240, ordering);
                          break;
  }
 add_arcs_according_to_ordering(newnetwork, edges, edgecount);
 make_conditional_tables(newnetwork);
 while (i < 5)
  {
   j = myrand() % 2;
   if (j)
     if (!remove_operator(newnetwork))
       i++;
     else
       i = 0;
   else
     if (!modify_operator(newnetwork))
       i++;
     else
       i = 0;
  }
 return newnetwork;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %r8d, %ebp
callq 0x266b6
testq %rax, %rax
je 0x8dabd
movq %rax, %rbx
movq %rax, %rdi
callq 0x2de7c
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x2e1e3
movq %rax, 0x38(%rbx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4dc1a
movq %rax, %r14
cmpl $0x3, %ebp
ja 0x8dae6
movl %ebp, %eax
leaq 0x20e2e(%rip), %rcx     # 0xae8d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x5300c
jmp 0x8daf6
xorl %ebx, %ebx
jmp 0x8db3b
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x530b5
jmp 0x8daf6
movq %rbx, %rdi
callq 0x5326c
jmp 0x8daf6
movq %rbx, %rdi
callq 0x5302c
jmp 0x8daf6
leaq 0x20e0b(%rip), %rdi     # 0xae8f8
movl %ebp, %esi
xorl %eax, %eax
callq 0x4030
movl 0x4(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e04e
movq %rbx, %rdi
callq 0x4e366
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x39f18
movq %rbx, %rdi
testb $0x1, %al
jne 0x8db27
callq 0x52e52
jmp 0x8db2c
callq 0x52d0c
incl %r14d
testl %eax, %eax
cmovnel %ebp, %r14d
cmpl $0x5, %r14d
jl 0x8db12
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: free_svm_split
void free_svm_split(Svm_split s)
{
	/*Last Changed 25.07.2005 added weights*/
	/*Last Changed 28.05.2005*/
	int i;
	safe_free(s.sv_coef);
	for (i = 0; i < s.l; i++)
		 safe_free(s.SV[i]);
	safe_free(s.SV);
	safe_free(s.weights);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %rbx
movq 0x68(%rbx), %rdi
callq 0x39194
movslq 0x58(%rbx), %r14
testq %r14, %r14
jle 0x8dda3
movq 0x60(%rbx), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x39194
incq %r12
cmpq %r12, %r14
jne 0x8dd92
movq 0x60(%rbx), %rdi
callq 0x39194
movq 0x78(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: free_svm_model
void free_svm_model(Svm_modelptr model)
{
 /*LAst Changed 04.01.2006 added probA and probB*/
	/*Last Changed 03.05.2005*/
	int i;
	safe_free(model->nSV);
	safe_free(model->rho);
	safe_free(model->SV);
	for (i = 0; i < model->nr_class - 1; i++)
		 safe_free(model->sv_coef[i]);
	safe_free(model->sv_coef);
 safe_free(model->probA);
 safe_free(model->probB);
	safe_free(model);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
callq 0x39194
movq 0x70(%rbx), %rdi
callq 0x39194
movq 0x60(%rbx), %rdi
callq 0x39194
cmpl $0x2, 0x58(%rbx)
jl 0x8de07
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x39194
incq %r14
movslq 0x58(%rbx), %rax
decq %rax
cmpq %rax, %r14
jl 0x8ddeb
movq 0x68(%rbx), %rdi
callq 0x39194
movq 0xa0(%rbx), %rdi
callq 0x39194
movq 0xa8(%rbx), %rdi
callq 0x39194
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: free_svm_problem
void free_svm_problem(Svm_problem prob)
{
	/*Last Changed 03.05.2005*/
	int i;
 if (prob.l > 0)
  {
	  safe_free(prob.y);
	  for (i = 0; i < prob.l; i++)
		   safe_free(prob.x[i]);
	  safe_free(prob.x);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq 0x30(%rsp), %rbx
testq %rbx, %rbx
jle 0x8de83
leaq 0x30(%rsp), %r14
movq 0x8(%r14), %rdi
callq 0x39194
movq 0x10(%r14), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x39194
incq %r12
cmpq %r12, %rbx
jne 0x8de5e
movq 0x10(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39194
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: solve_c_svc
void solve_c_svc(Svm_problem prob, Svm_parameter param, double *alpha, Solutioninfoptr si, double Cp, double Cn)
{
	/*Last Changed 29.04.2005*/
	int i, l = prob.l;
	double *minus_ones, sum_alpha = 0.0;
	signed char* y;
	Solverptr s;
 minus_ones = safemalloc(l * sizeof(double), "solve_c_svc", 5);
	y = safemalloc(l * sizeof(signed char), "solve_c_svc", 6);
	s = safemalloc(sizeof(Solver), "solve_c_svc", 7);
	for (i = 0; i < l; i++)
	 {
		 alpha[i] = 0;
		 minus_ones[i] = -1;
		 if (prob.y[i] > 0) 
				 y[i] = +1; 
			else 
				 y[i] = -1;
	 }
	solve(s, l, QC, minus_ones, y, alpha, Cp, Cn, si, prob, param, 0);
	for (i = 0; i < l; i++)
		 sum_alpha += alpha[i];
	for (i = 0; i < l; i++)
		 alpha[i] *= y[i];
	safe_free(s);
	safe_free(minus_ones);
	safe_free(y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movsd %xmm1, 0xa0(%rsp)
movsd %xmm0, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdi, %rbx
leaq 0xe0(%rsp), %rbp
movslq (%rbp), %r14
leaq (,%r14,8), %rdi
leaq 0x20a9c(%rip), %r13     # 0xae974
movq %r13, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, %r15
movq %r14, %rdi
movq %r13, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, %r12
movl $0x80, %edi
movq %r13, %rsi
movl $0x7, %edx
callq 0x390f5
movq %rax, %r13
testq %r14, %r14
jle 0x8df52
xorl %eax, %eax
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
xorpd %xmm0, %xmm0
movq $0x0, (%rbx,%rax,8)
movq %rcx, (%r15,%rax,8)
movq 0x8(%rbp), %rdx
movsd (%rdx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
setbe %dl
negb %dl
orb $0x1, %dl
movb %dl, (%r12,%rax)
incq %rax
cmpq %rax, %r14
jne 0x8df25
leaq 0x28(%rsp), %rdi
movl $0xb, %ecx
leaq 0x100(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x80(%rsp)
movq %r13, %rdi
movl %r14d, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %r12, %r8
movq %rbx, %r9
movsd 0x98(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm1
callq 0x93fc4
testl %r14d, %r14d
jle 0x8dfdd
xorl %eax, %eax
movsbl (%r12,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x8dfbf
movq %r13, %rdi
callq 0x39194
movq %r15, %rdi
callq 0x39194
movq %r12, %rdi
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: solve_one_class
void solve_one_class(Svm_problem prob, Svm_parameter param, double *alpha, Solutioninfoptr si)
{
	/*Last Changed 29.04.2005*/
	Solverptr s;
	int l = prob.l, i, n;
	double *zeros; 
	signed char *ones; 
 zeros = safemalloc(l * sizeof(double), "solve_one_class", 5);
	ones = safemalloc(l * sizeof(signed char), "solve_one_class", 6);
	s = safemalloc(sizeof(Solver), "solve_one_class", 7);
 n = (int)(param.nu * prob.l);	
	for (i = 0; i < n; i++)
		 alpha[i] = 1;
	alpha[n] = param.nu * prob.l - n;
	for (i = n + 1; i < l; i++)
		 alpha[i] = 0;
	for (i = 0; i < l; i++)
	 {
 		zeros[i] = 0;
 		ones[i] = 1;
	 }
	solve(s, l, QONE, zeros, ones, alpha, 1.0, 1.0, si, prob, param, 0);
	safe_free(s);
	safe_free(zeros);
	safe_free(ones);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r13
movq %rdi, %r14
movslq 0xc0(%rsp), %r12
leaq (,%r12,8), %rdi
leaq 0x2073a(%rip), %rbp     # 0xae98d
movq %rbp, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, %rbx
movq %r12, %rdi
movq %rbp, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, %r15
movl $0x80, %edi
movq %rbp, %rsi
movl $0x7, %edx
callq 0x390f5
cvtsi2sdl 0xc0(%rsp), %xmm0
mulsd 0x120(%rsp), %xmm0
movq %rax, %rbp
cvttsd2si %xmm0, %eax
testl %eax, %eax
jle 0x8e2bf
movl %eax, %ecx
xorl %edx, %edx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
movq %rsi, (%r14,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x8e2b3
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movslq %eax, %rcx
movsd %xmm0, (%r14,%rcx,8)
leal 0x1(%rax), %ecx
cmpl %r12d, %ecx
jge 0x8e2f6
movslq %ecx, %rcx
leaq (%r14,%rcx,8), %rdi
movl %r12d, %ecx
subl %eax, %ecx
addl $-0x2, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
callq 0x4050
leaq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rax
testl %r12d, %r12d
jle 0x8e322
xorl %ecx, %ecx
movq $0x0, (%rbx,%rcx,8)
movb $0x1, (%r15,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x8e30d
leaq 0x28(%rsp), %rdi
movl $0xb, %ecx
rep  movsq (%rsi), %es:(%rdi)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movq %r13, (%rsp)
movl $0x0, 0x80(%rsp)
movsd 0x141c9(%rip), %xmm0    # 0xa2520
movq %rbp, %rdi
movl %r12d, %esi
movl $0x2, %edx
movq %rbx, %rcx
movq %r15, %r8
movq %r14, %r9
movaps %xmm0, %xmm1
callq 0x93fc4
movq %rbp, %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x39194
movq %r15, %rdi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: solve_epsilon_svr
void solve_epsilon_svr(Svm_problem prob, Svm_parameter param, double *alpha, Solutioninfoptr si)
{
	/*Last Changed 29.04.2005*/
	Solverptr s;
	int l = prob.l, i;
	double *alpha2, *linear_term, sum_alpha;
	signed char* y;
 alpha2 = safemalloc(2 * l * sizeof(double), "solve_epsilon_svr", 5);
 linear_term = safemalloc(2 * l * sizeof(double), "solve_epsilon_svr", 6);
	y = safemalloc(2 * l * sizeof(signed char), "solve_epsilon_svr", 7);
	s = safemalloc(sizeof(Solver), "solve_epsilon_svr", 8);
	for (i = 0; i < l; i++)
	 {
 		alpha2[i] = 0;
	 	linear_term[i] = param.p - prob.y[i];
		 y[i] = 1;
		 alpha2[i + l] = 0;
		 linear_term[i + l] = param.p + prob.y[i];
		 y[i + l] = -1;
	 }
 solve(s, 2 * l, QR, linear_term, y, alpha2, param.C, param.C, si, prob, param, 0);
 sum_alpha = 0;
	for (i = 0; i < l; i++)
	 {
 		alpha[i] = alpha2[i] - alpha2[i+l];
		 sum_alpha += fabs(alpha[i]);
	 }
	safe_free(s);
	safe_free(alpha2);
	safe_free(linear_term);
	safe_free(y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdi, 0xa0(%rsp)
leaq 0x100(%rsp), %rbp
leaq 0xe0(%rsp), %rbx
movslq (%rbx), %r15
leaq (%r15,%r15), %r13
movq %r15, %r12
shlq $0x4, %r12
leaq 0x205bb(%rip), %rsi     # 0xae99d
movq %r12, %rdi
movl $0x5, %edx
callq 0x390f5
movq %rax, %r14
movq %r12, %rdi
leaq 0x205a1(%rip), %r12     # 0xae99d
movq %r12, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, 0x88(%rsp)
movq %r13, 0x90(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r12, %r13
movl $0x7, %edx
callq 0x390f5
movq %rax, %r12
movl $0x80, %edi
movq %r13, %rsi
movl $0x8, %edx
callq 0x390f5
movq 0x88(%rsp), %r8
movq %rax, %r9
leaq (%r14,%r15,8), %r13
testq %r15, %r15
jle 0x8e4a4
movq %r12, %rax
addq %r15, %rax
leaq (%r8,%r15,8), %rcx
xorl %edx, %edx
xorl %esi, %esi
movq %rdx, (%r14,%rsi,8)
movsd 0x48(%rbp), %xmm0
movq 0x8(%rbx), %rdi
subsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%r8,%rsi,8)
movb $0x1, (%r12,%rsi)
movq %rdx, (%r13,%rsi,8)
movsd 0x48(%rbp), %xmm0
movq 0x8(%rbx), %rdi
addsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
movb $-0x1, (%rax,%rsi)
incq %rsi
cmpq %rsi, %r15
jne 0x8e463
movsd 0x30(%rbp), %xmm0
leaq 0x28(%rsp), %rdi
movl $0xb, %ecx
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movups (%rbx), %xmm1
movups 0x10(%rbx), %xmm2
movups %xmm2, 0x18(%rsp)
movups %xmm1, 0x8(%rsp)
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x80(%rsp)
movq %r9, %rbp
movq %r9, %rdi
movq 0x90(%rsp), %rsi
movl $0x1, %edx
movq %r8, %rbx
movq %r8, %rcx
movq %r12, %r8
movq %r14, %r9
movapd %xmm0, %xmm1
callq 0x93fc4
testl %r15d, %r15d
movq 0xa0(%rsp), %rcx
jle 0x8e532
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm0
subsd (%r13,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x8e518
movq %rbp, %rdi
callq 0x39194
movq %r14, %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x39194
movq %r12, %rdi
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: svm_group_classes
int svm_group_classes(Svm_problem prob, int **start_ret, int **count_ret, int *perm)
{
	/*Last Changed 02.05.2005*/
	int l,  *count, *data_label, i, classno, *start, classes[MAXCLASSES], nr_class = 0;
 l = prob.l;
 for (i = 0; i < l; i++)
	  search_and_add_into_list(classes, &nr_class, (int)prob.y[i]);
 count = safecalloc(nr_class, sizeof(int), "svm_group_classes", 5);
	data_label = safemalloc(l * sizeof(int), "svm_group_classes", 6);
	for (i = 0; i < l; i++)
	 {
		 classno = search_list(classes, nr_class, (int)prob.y[i]);
			(count[classno])++;
		 data_label[i] = classno;
	 }
	start = safemalloc(nr_class * sizeof(int), "svm_group_classes", 11);
	start[0] = 0;
	for (i = 1;i < nr_class; i++)
		 start[i] = start[i - 1] + count[i - 1];
	for (i = 0; i < l; i++)
	 {
 		perm[start[data_label[i]]] = i;
		 ++start[data_label[i]];
	 }
	start[0] = 0;
	for (i = 1;i < nr_class; i++)
		 start[i] = start[i - 1] + count[i - 1];
	*start_ret = start;
	*count_ret = count;
	safe_free(data_label);
 return nr_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x120(%rsp), %rbp
movl $0x0, 0x4(%rsp)
movslq (%rbp), %rbx
testq %rbx, %rbx
jle 0x8e9fa
movq 0x8(%rbp), %r14
xorl %r15d, %r15d
leaq 0x20(%rsp), %r12
leaq 0x4(%rsp), %r13
cvttsd2si (%r14,%r15,8), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x37984
incq %r15
cmpq %r15, %rbx
jne 0x8e9e1
movslq 0x4(%rsp), %rdi
leaq 0x1ffeb(%rip), %r13     # 0xae9f1
movl $0x4, %esi
movq %r13, %rdx
movl $0x5, %ecx
callq 0x39210
movq %rax, %r12
leaq (,%rbx,4), %rdi
movq %r13, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, %r13
testl %ebx, %ebx
jle 0x8ea68
movq 0x8(%rbp), %r14
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbp
movl 0x4(%rsp), %esi
cvttsd2si (%r14,%r15,8), %edx
movq %rbp, %rdi
callq 0x379c4
cltq
incl (%r12,%rax,4)
movl %eax, (%r13,%r15,4)
incq %r15
cmpq %r15, %rbx
jne 0x8ea43
movslq 0x4(%rsp), %rdi
shlq $0x2, %rdi
leaq 0x1ff79(%rip), %rsi     # 0xae9f1
movl $0xb, %edx
callq 0x390f5
movl $0x0, (%rax)
cmpl $0x2, 0x4(%rsp)
jl 0x8eaab
movl (%rax), %ecx
movl $0x1, %edx
addl -0x4(%r12,%rdx,4), %ecx
movl %ecx, (%rax,%rdx,4)
incq %rdx
movslq 0x4(%rsp), %rsi
cmpq %rsi, %rdx
jl 0x8ea96
testl %ebx, %ebx
movq 0x8(%rsp), %rsi
jle 0x8ead2
xorl %ecx, %ecx
movslq (%r13,%rcx,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl %ecx, (%rsi,%rdx,4)
movslq (%r13,%rcx,4), %rdx
incl (%rax,%rdx,4)
incq %rcx
cmpq %rcx, %rbx
jne 0x8eab6
movl $0x0, (%rax)
cmpl $0x2, 0x4(%rsp)
jl 0x8eafb
movl (%rax), %ecx
movl $0x1, %edx
addl -0x4(%r12,%rdx,4), %ecx
movl %ecx, (%rax,%rdx,4)
incq %rdx
movslq 0x4(%rsp), %rsi
cmpq %rsi, %rdx
jl 0x8eae6
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0x18(%rsp), %rax
movq %r12, (%rax)
movq %r13, %rdi
callq 0x39194
movl 0x4(%rsp), %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: sigmoid_predict
double sigmoid_predict(double decision_value, double A, double B)
{
 double fApB = decision_value * A + B;
 if (fApB >= 0)
   return exp(-fApB) / (1.0 + exp(-fApB));
 else
   return 1.0 / (1 + exp(fApB)) ;
}

// Assembly:
subq $0x28, %rsp
movapd %xmm0, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jae 0x9043a
movsd 0x120e8(%rip), %xmm0    # 0xa2520
jmp 0x90457
xorpd 0x12d8e(%rip), %xmm3    # 0xa31d0
movapd %xmm3, 0x10(%rsp)
movapd %xmm3, %xmm0
callq 0x4060
movapd 0x10(%rsp), %xmm3
movsd %xmm0, 0x8(%rsp)
movapd %xmm3, %xmm0
callq 0x4060
addsd 0x120b2(%rip), %xmm0    # 0xa2520
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: svm_predict_probability
void svm_predict_probability(Svm_modelptr model, Svm_nodeptr x, double* prob_estimates)
{
 /*Last Changed 04.01.2006*/
 int i, j, nr_class, k = 0;
 double *dec_values, min_prob = 1e-7, **pairwise_prob;
 nr_class = model->nr_class;
 dec_values = safemalloc((nr_class * (nr_class - 1) / 2) * sizeof(double), "svm_predict_probability", 4);
 svm_predict_values(model, x, dec_values);
 pairwise_prob = (double **) safemalloc_2d(sizeof(double*), sizeof(double), nr_class, nr_class, "svm_predict_probability", 6);
 for (i = 0; i < nr_class; i++)
   for (j = i + 1; j < nr_class; j++)
    {
     pairwise_prob[i][j] = fmin(fmax(sigmoid_predict(dec_values[k], model->probA[k], model->probB[k]), min_prob), 1 - min_prob);
     pairwise_prob[j][i] = 1 - pairwise_prob[i][j];
     k++;
    }
 multiclass_probability(nr_class, pairwise_prob, prob_estimates);
 free_2d((void**)pairwise_prob, nr_class);
 safe_free(dec_values);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
movslq 0x58(%rdi), %r14
leal -0x1(%r14), %eax
imull %r14d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rdi
shlq $0x3, %rdi
leaq 0x1e2fb(%rip), %rbp     # 0xaea76
movq %rbp, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, 0x10(%rsp)
movq %rax, %rdx
callq 0x8faf6
movl $0x8, %r15d
movl $0x8, %edi
movl $0x8, %esi
movl %r14d, %edx
movl %r14d, %ecx
movq %rbp, %r8
movl $0x6, %r9d
callq 0x393b5
movq %rax, %rcx
testq %r14, %r14
jle 0x908cb
movq %rcx, %rdx
addq $0x8, %rdx
leaq -0x1(%r14), %r13
xorl %eax, %eax
xorl %edi, %edi
movq %r14, 0x20(%rsp)
movq %rbx, 0x30(%rsp)
movq %rax, %r8
incq %rax
cmpq %r14, %rax
jae 0x908b7
movq %rax, 0x28(%rsp)
movl %edi, 0xc(%rsp)
movslq %edi, %rdi
movq 0x10(%rsp), %rax
leaq (%rax,%rdi,8), %rax
movq %rax, 0x38(%rsp)
shlq $0x3, %rdi
movq %rdi, 0x40(%rsp)
xorl %ebp, %ebp
movq 0x38(%rsp), %rax
movsd (%rax,%rbp,8), %xmm0
movq 0xa0(%rbx), %rax
movq 0x40(%rsp), %rdi
addq %rdi, %rax
movsd (%rax,%rbp,8), %xmm1
movq 0xa8(%rbx), %rax
addq %rdi, %rax
movsd (%rax,%rbp,8), %xmm2
movq %rcx, %r12
movq %rdx, %rbx
movq %r8, %r14
callq 0x90416
movq %r14, %r8
movsd 0x1e0e2(%rip), %xmm2    # 0xae940
movsd 0x1e0d2(%rip), %xmm1    # 0xae938
movq %rbx, %rdx
movq %r12, %rcx
movq 0x30(%rsp), %rbx
maxsd %xmm1, %xmm0
minsd %xmm2, %xmm0
movsd 0x11c9f(%rip), %xmm1    # 0xa2520
movq (%r12,%r14,8), %rax
addq %r15, %rax
movsd %xmm0, (%rax,%rbp,8)
subsd %xmm0, %xmm1
movq (%rdx,%rbp,8), %rax
movsd %xmm1, (%rax,%r14,8)
incq %rbp
cmpq %rbp, %r13
jne 0x90818
movl 0xc(%rsp), %edi
addl %ebp, %edi
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rax
addq $0x8, %rdx
addq $0x8, %r15
decq %r13
cmpq %r14, %rax
jne 0x907e4
movl %r14d, %edi
movq %rcx, %rbx
movq %rcx, %rsi
movq 0x18(%rsp), %rdx
callq 0x90481
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3915f
movq 0x10(%rsp), %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svm.c
// Function: svm_predict
double svm_predict(Svm_modelptr model, Svm_nodeptr x)
{
	/*Last Changed 02.05.2005*/
 int i, j, nr_class, *vote, pos = 0, vote_max_idx;
	double res, *dec_values;
	if (in_list(model->param.svm_type, 3, ONE_CLASS, EPSILON_SVR, NU_SVR))
	 {
		 svm_predict_values(model, x, &res);		
		 if (model->param.svm_type == ONE_CLASS)
				 if (res > 0)
						 return 1;
					else
						 return -1;
		 else
			  return res;
	 }
	else
	 {
		 nr_class = model->nr_class;
		 dec_values = safemalloc(sizeof(double) * nr_class * (nr_class-1) / 2, "svm_predict", 17);
		 svm_predict_values(model, x, dec_values);
		 vote = safemalloc(sizeof(int) * nr_class, "svm_predict", 19);
		 for (i = 0; i < nr_class; i++)
			  vote[i] = 0;
		 for (i = 0; i < nr_class; i++)
  			for (j = i + 1; j < nr_class; j++)
					 {
				   if (dec_values[pos] > 0)
    					++vote[i];
			   	else
					    ++vote[j];
				   pos++;
					 }  
		 vote_max_idx = 0;
		 for (i = 1; i < nr_class; i++)
			  if (vote[i] > vote[vote_max_idx])
				   vote_max_idx = i;
		 safe_free(vote);
		 safe_free(dec_values);
		 return vote_max_idx;
	 }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %edi
movl $0x3, %esi
movl $0x2, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x90975
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x8faf6
cmpl $0x2, (%r14)
movsd (%rbx), %xmm0
jne 0x90a8f
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x1dfe5(%rip), %rcx     # 0xae950
movsd (%rcx,%rax,8), %xmm0
jmp 0x90a8f
movslq 0x58(%r14), %r13
leaq -0x1(%r13), %rax
imulq %r13, %rax
shlq $0x2, %rax
movabsq $0x7ffffffffffffffc, %rdi # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rdi
leaq 0x1e0f5(%rip), %r12     # 0xaea8e
movq %r12, %rsi
movl $0x11, %edx
callq 0x390f5
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8faf6
leaq (,%r13,4), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x13, %edx
callq 0x390f5
movq %rax, %r14
testq %r13, %r13
jle 0x909e4
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4050
testl %r13d, %r13d
jle 0x90a42
movq %r13, %rax
negq %rax
xorl %ecx, %ecx
movl $0x1, %edx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movq %rcx, %rdi
incq %rcx
cmpq %r13, %rcx
jae 0x90a3a
movslq %esi, %r8
leaq (%rax,%rdx), %r9
leaq (%rbx,%r8,8), %r10
xorl %r8d, %r8d
movsd (%r10,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
movq %rdi, %r11
ja 0x90a28
leaq (%rdx,%r8), %r11
incl (%r14,%r11,4)
incq %r8
movq %r9, %r11
addq %r8, %r11
jne 0x90a15
addl %r8d, %esi
incq %rdx
cmpq %r13, %rcx
jne 0x909fc
xorpd %xmm0, %xmm0
cmpl $0x2, %r13d
jl 0x90a75
xorl %ecx, %ecx
movl $0x1, %eax
movl (%r14,%rax,4), %esi
movslq %ecx, %rdi
movl %eax, %edx
cmpl (%r14,%rdi,4), %esi
jg 0x90a64
movl %ecx, %edx
incq %rax
movl %edx, %ecx
cmpq %rax, %r13
jne 0x90a53
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x39194
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)