LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: export_single_file
void export_single_file(char* separator, int exporttype, int runno, int foldno, Instanceptr data1, Instanceptr data2)
{
 /*!Last Changed 21.04.2007*/
 FILE* outfile;
 char* fname;
 fname = export_file_name(current_dataset, exporttype, runno + 1, foldno + 1, -1);
 if (!fname)
   return;
 outfile = fopen(fname, "w");
 if (!outfile)
   return;
 if (get_parameter_l("namestype") == NAMES_CMU)
  {
   print_cmu_data_header(outfile, current_dataset);
   fprintf(outfile, "$TRAIN\n");
   print_instance_list(outfile, *separator, current_dataset, data1);
   fprintf(outfile, "$TEST\n");
   print_instance_list(outfile, *separator, current_dataset, data2);
  }
 else
   print_instance_list(outfile, *separator, current_dataset, data1);
 fclose(outfile);
 safe_free(fname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r12
movq %rdi, %r14
movq 0x74c30(%rip), %rdi     # 0xd2870
incl %edx
incl %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x5c226
testq %rax, %rax
je 0x5dcdc
movq %rax, %r15
leaq 0x4ac3f(%rip), %rsi     # 0xa88a1
movq %rax, %rdi
callq 0x40f0
testq %rax, %rax
je 0x5dcdc
movq %rax, %r13
leaq 0x46400(%rip), %rdi     # 0xa4079
callq 0x535f7
cmpl $0x5, %eax
jne 0x5dce6
movq 0x74be6(%rip), %rsi     # 0xd2870
movq %r13, %rdi
callq 0x190f1
leaq 0x4aca7(%rip), %rdi     # 0xa8940
movl $0x7, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x42c0
movsbl (%r14), %esi
movq 0x74bba(%rip), %rdx     # 0xd2870
movq %r13, %rdi
movq %r12, %rcx
callq 0x2fbad
leaq 0x4ac80(%rip), %rdi     # 0xa8948
movl $0x6, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x42c0
jmp 0x5dce9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rbx
movsbl (%r14), %esi
movq 0x74b7c(%rip), %rdx     # 0xd2870
movq %r13, %rdi
movq %rbx, %rcx
callq 0x2fbad
movq %r13, %rdi
callq 0x42a0
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: read_data_from_lines_with_probability
void read_data_from_lines_with_probability(char** lines, int linecount, double* probability, Instanceptr* data)
{
 /*!Last Changed 28.02.2006*/
 int i, bin;
 double val;
 Instanceptr currentinstance, before;
 for (i = 0; i < linecount; i++)
  {
   val = produce_random_value(0.0, 1.0);
   bin = find_bin(probability, linecount, val);
   currentinstance = create_instance(current_dataset, lines[bin], NO);
   if (i == 0)
     *data = currentinstance;
   else
     before->next = currentinstance;
   before = currentinstance;
  }
}

// Assembly:
testl %esi, %esi
jle 0x602ca
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movsd 0x422a1(%rip), %xmm1    # 0xa2520
callq 0x39f62
movq %r14, %rdi
movl %ebp, %esi
callq 0x374dd
movq 0x725db(%rip), %rdi     # 0xd2870
cltq
movq (%r15,%rax,8), %rsi
xorl %edx, %edx
callq 0x1847e
addq $0x10, %r13
testl %r12d, %r12d
cmoveq %rbx, %r13
movq %rax, (%r13)
incl %r12d
movq %rax, %r13
cmpl %r12d, %ebp
jne 0x60274
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/process.c
// Function: free_train_and_test_lines
void free_train_and_test_lines()
{
 /*!Last Changed 05.03.2006*/
 free_2d((void**)trainlines, trainlinecount);
 trainlinecount = 0;
 trainlines = NULL;
 if (get_parameter_f("testpercentage") > 0.0)
  {
   free_2d((void**)testlines, testlinecount);
   testlinecount = 0;
   testlines = NULL;
  }
}

// Assembly:
pushq %rax
movq 0x72541(%rip), %rdi     # 0xd2860
movl 0x721eb(%rip), %esi     # 0xd2510
callq 0x3915f
movl $0x0, 0x721dc(%rip)     # 0xd2510
movq $0x0, 0x72521(%rip) # 0xd2860
leaq 0x4873d(%rip), %rdi     # 0xa8a83
callq 0x534b6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6037c
movq 0x724fc(%rip), %rdi     # 0xd2858
movl 0x721aa(%rip), %esi     # 0xd250c
callq 0x3915f
movl $0x0, 0x7219b(%rip)     # 0xd250c
movq $0x0, 0x724dc(%rip) # 0xd2858
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: read_train_lines
void read_train_lines()
{
 /*!Last Changed 08.01.2009*/
 char myline[READLINELENGTH];
 if (!open_dataset(current_dataset))
   return;  
 while (get_single_instance(current_dataset, myline))
  {
   if (is_line_comment(myline))
     continue;
   add_single_data_line(&trainlines, &trainlinecount, myline);
  }
 close_dataset(current_dataset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq 0x724df(%rip), %rdi     # 0xd2870
callq 0x5ce9c
testl %eax, %eax
je 0x603eb
movq %rsp, %rsi
callq 0x5cda0
testq %rax, %rax
je 0x603df
movq %rsp, %rbx
leaq 0x724af(%rip), %r14     # 0xd2860
leaq 0x72158(%rip), %r15     # 0xd2510
movq %rbx, %rdi
callq 0x39520
testl %eax, %eax
jne 0x603d2
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x602cb
movq %rbx, %rsi
callq 0x5cda0
testq %rax, %rax
jne 0x603b8
movq 0x7248a(%rip), %rdi     # 0xd2870
callq 0x5cf32
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: check_and_set_list_variable
void check_and_set_list_variable(void* variable, char* errormessage1, char* errormessage2, char* valuelist[], int listlength)
{
 /*!Last Changed 22.11.2004*/
 int tmp, i;
 if (checkparams(paramcount, 1, errormessage1))
  {
   tmp = listindex(params[0], valuelist, listlength);
   if (tmp != -1)
     *((int*)variable) = tmp;
   else
    {
     printf(errormessage2, params[0]);
     printf(m1276);
     for (i = 0; i < listlength; i++)
      {
       printf("%s", valuelist[i]);
       printf("\n");
      }
     printf("Current value: %s\n", valuelist[*((int*)variable)]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
movl 0x34269a(%rip), %edi    # 0x3aefa0
movl $0x1, %esi
xorl %eax, %eax
callq 0x39b2e
testl %eax, %eax
je 0x6c92f
movq 0x65c13(%rip), %rdi     # 0xd2530
movq %rbx, %rsi
movl %ebp, %edx
callq 0x3a2c5
cmpl $-0x1, %eax
je 0x6c93e
movl %eax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x65beb(%rip), %rsi     # 0xd2530
movq %r15, %rdi
xorl %eax, %eax
callq 0x4030
leaq 0x3b180(%rip), %rdi     # 0xa7ad6
callq 0x4090
testl %ebp, %ebp
jle 0x6c98c
movl %ebp, %r12d
leaq 0x3858f(%rip), %r15     # 0xa4ef8
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4030
movl $0xa, %edi
callq 0x40d0
incq %r13
cmpq %r13, %r12
jne 0x6c96c
movslq (%r14), %rax
movq (%rbx,%rax,8), %rsi
leaq 0x3c2e2(%rip), %rdi     # 0xa8c7c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: deallocate_remaining_memory
void deallocate_remaining_memory()
{
 /*!Last Changed 29.11.2004*/
 int res;
 for (res = 0; res < graphcount; res++)
   deallocate_graph(Graphs[res]);
 deallocate_datasets();
 free_variables(vars, varcount);
 safe_free(vars);
 if (datadir)
   safe_free(datadir);
 if (prior_class_information)
   safe_free(prior_class_information); 
 if (traindata)
  {
   deallocate(traindata);
   traindata = NULL;
  }
 if (testdata)
  {
   deallocate(testdata);
   testdata = NULL;
  } 
 if (cvdata)
  {
   deallocate(cvdata);
   cvdata = NULL;
  }
 deallocate_orders();
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x65b49(%rip)     # 0xd2500
jle 0x6c9da
xorl %ebx, %ebx
movq 0x2c84a6(%rip), %rax    # 0x334e68
movq (%rax,%rbx,8), %rdi
callq 0x4d6dd
incq %rbx
movslq 0x65b2b(%rip), %rax     # 0xd2500
cmpq %rax, %rbx
jl 0x6c9bb
xorl %eax, %eax
callq 0x1373f
movq 0x65e80(%rip), %rdi     # 0xd2868
movl 0x65b16(%rip), %esi     # 0xd2504
callq 0x33e6d
movq 0x65e6e(%rip), %rdi     # 0xd2868
callq 0x39194
movq 0x65e7a(%rip), %rdi     # 0xd2880
testq %rdi, %rdi
je 0x6ca10
callq 0x39194
movq 0x2c8441(%rip), %rdi    # 0x334e58
testq %rdi, %rdi
je 0x6ca21
callq 0x39194
movq 0x2c8408(%rip), %rdi    # 0x334e30
testq %rdi, %rdi
je 0x6ca3d
callq 0x2f616
movq $0x0, 0x2c83f3(%rip) # 0x334e30
movq 0x2c83f4(%rip), %rdi    # 0x334e38
testq %rdi, %rdi
je 0x6ca59
callq 0x2f616
movq $0x0, 0x2c83df(%rip) # 0x334e38
movq 0x2c83e0(%rip), %rdi    # 0x334e40
testq %rdi, %rdi
je 0x6ca75
callq 0x2f616
movq $0x0, 0x2c83cb(%rip) # 0x334e40
xorl %eax, %eax
popq %rbx
jmp 0xe1ec
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: os_command
void os_command(OPERATING_SYSTEM_COMMAND_TYPE cmd_index)
{
 /*!Last Changed 19.04.2007*/
 int i;
 char st[MAXLENGTH];
 switch (get_parameter_l("currentos"))
  {
   case WINDOWS:strcpy(st, windows_commands[cmd_index]);
                break;
   case SOLARIS:
   case   LINUX:strcpy(st, linux_commands[cmd_index]);
                break;
  }
 for (i = 0; i < paramcount; i++)
   sprintf(st, "%s %s", st, params[i]);
 system(st);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movl %edi, %ebx
leaq 0x37727(%rip), %rdi     # 0xa41bc
callq 0x535f7
cmpl $0x2, %eax
ja 0x6caba
movl %eax, %eax
leaq 0x642f0(%rip), %rcx     # 0xd0d98
movq (%rcx,%rax,8), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rsi
movq %rsp, %rdi
callq 0x4270
cmpl $0x0, 0x3424df(%rip)    # 0x3aefa0
jle 0x6cafd
leaq 0x65a66(%rip), %r15     # 0xd2530
leaq 0x4093c(%rip), %rbx     # 0xad40d
movq %rsp, %r14
xorl %r12d, %r12d
movq (%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x41b0
incq %r12
movslq 0x3424ac(%rip), %rax    # 0x3aefa0
addq $0x8, %r15
cmpq %rax, %r12
jl 0x6cad7
movq %rsp, %rdi
callq 0x4100
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/pstricks.c
// Function: write_rectangle_pstricks
void write_rectangle_pstricks(FILE* myfile, double corner1x, double corner1y, double corner2x, double corner2y, FILL_TYPE filltype, int color)
{
 switch (filltype)
  {
   case FILL_NONE      :fprintf(myfile, "\\psframe(%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_FLOOD     :fprintf(myfile, "\\psframe[fillstyle=solid,fillcolor=black](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_GRAY      :fprintf(myfile, "\\psframe[fillstyle=solid,fillcolor=lightgray](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_VERTICAL  :fprintf(myfile, "\\psframe[fillstyle=vlines](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_HORIZONTAL:fprintf(myfile, "\\psframe[fillstyle=hlines](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_SQUARE    :fprintf(myfile, "\\psframe[fillstyle=crosshatch](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_COLOR     :fprintf(myfile, "\\psframe[fillstyle=solid,fillcolor=%s](%f, %f)(%f, %f)\n", pstrickscolors[color], corner1x, corner1y, corner2x, corner2y);
                        break;
  }
}

// Assembly:
cmpl $0x6, %esi
ja 0x6cb85
movl %esi, %eax
leaq 0x3f13f(%rip), %rcx     # 0xabc84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3f2c1(%rip), %rsi     # 0xabe16
jmp 0x6cb9f
movslq %edx, %rax
leaq 0x6574f(%rip), %rcx     # 0xd22b0
movq (%rcx,%rax,8), %rdx
leaq 0x3f3c6(%rip), %rsi     # 0xabf32
movb $0x4, %al
jmp 0x42e0
leaq 0x3f2f1(%rip), %rsi     # 0xabe6b
jmp 0x6cb9f
leaq 0x3f37f(%rip), %rsi     # 0xabf02
jmp 0x6cb9f
retq
leaq 0x3f2a3(%rip), %rsi     # 0xabe30
jmp 0x6cb9f
leaq 0x3f314(%rip), %rsi     # 0xabeaa
jmp 0x6cb9f
leaq 0x3f337(%rip), %rsi     # 0xabed6
movb $0x4, %al
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/pstricks.c
// Function: position_in_multi_plot_pstricks
double position_in_multi_plot_pstricks(int groupindex, int index, int groupcount, int elementcount, double* barwidth)
{
 double emptywidth;
 emptywidth = ((sqrt(5) - 1) / ((elementcount + 2) * sqrt(5) + (elementcount - 2)));
 *barwidth = ((sqrt(5) + 1) / ((elementcount + 2) * sqrt(5) + (elementcount - 2)));
 return groupindex + emptywidth + index * (*barwidth);
}

// Assembly:
leal 0x2(%rcx), %eax
cvtsi2sd %eax, %xmm0
addl $-0x2, %ecx
cvtsi2sd %ecx, %xmm1
mulsd 0x387ba(%rip), %xmm0    # 0xa5880
addsd %xmm1, %xmm0
movsd 0x387b6(%rip), %xmm1    # 0xa5888
divsd %xmm0, %xmm1
movsd 0x387b2(%rip), %xmm2    # 0xa5890
cvtsi2sd %edi, %xmm3
divsd %xmm0, %xmm2
addsd %xmm1, %xmm3
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm2, (%r8)
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rbf.c
// Function: allocate_rbfnetwork
Rbfnetworkptr allocate_rbfnetwork(Rbf_parameterptr params)
{
	/*!Last Changed 19.08.2007*/
	Rbfnetworkptr network;
	network = safemalloc(sizeof(Rbfnetwork), "allocate_rbfnetwork", 2);
	network->hidden = params->hidden;
	network->output = params->output;
	network->input = params->input;
 allocate_rbfweights(&(network->weights), params);
	return network;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e164(%rip), %rsi     # 0xac649
movl $0x40, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
movl 0x4(%rbx), %eax
movl %eax, (%r14)
movl (%rbx), %eax
movl %eax, 0x4(%r14)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x6e487
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rbf.c
// Function: initialize_rbfnetwork
void initialize_rbfnetwork(Rbfnetworkptr network, Instanceptr data, Rbf_parameterptr params)
{
	/*!Last Changed 20.08.2007*/
	int i, j;
	double* spreads;
	Instanceptr clustermeans, tmp;
	clustermeans = k_means_clustering(data, params->hidden);
	tmp = clustermeans;
	for (i = 0; i < params->hidden; i++)
	 {
		 for (j = 0; j < network->input; j++)
				 network->weights.m.values[i][j] = real_feature(tmp, j);
		 tmp = tmp->next;
	 }
	spreads = cluster_spreads(data, clustermeans, params->hidden);
 for (i = 0; i < params->hidden; i++)
   network->weights.s.values[0][i] = spreads[i];
	assignTwoDimRandomWeights(&(network->weights.w), params->randrange);
	deallocate(clustermeans);
	safe_free(spreads);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl 0x4(%rdx), %esi
movq %r12, %rdi
callq 0xcd5b
movq %rax, %r13
movl 0x4(%rbx), %edx
testl %edx, %edx
jle 0x6e591
xorl %r15d, %r15d
movq %r13, (%rsp)
cmpl $0x0, 0x8(%r14)
jle 0x6e57d
xorl %ebp, %ebp
movq %r13, %rdi
movl %ebp, %esi
callq 0x2e4b6
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jl 0x6e55a
movq 0x10(%r13), %r13
incq %r15
movslq 0x4(%rbx), %rdx
cmpq %rdx, %r15
jl 0x6e551
movq (%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xcc34
movq %rax, %r12
movslq 0x4(%rbx), %rax
testq %rax, %rax
jle 0x6e5c4
movq 0x28(%r14), %rcx
movq (%rcx), %rcx
xorl %edx, %edx
movsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x6e5b1
addq $0x30, %r14
movsd 0x20(%rbx), %xmm0
movq %r14, %rdi
callq 0x3e36c
movq %r13, %rdi
callq 0x2f616
movq %r12, %rdi
addq $0x8, %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/rbf.c
// Function: copy_of_rbfnetwork
Rbfnetworkptr copy_of_rbfnetwork(Rbfnetworkptr network, Rbf_parameterptr params)
{
	/*!Last Changed 19.08.2007*/
	Rbfnetworkptr copy;
	copy = allocate_rbfnetwork(params);
 copy_rbfweights(&(copy->weights), network->weights);
	return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6e4d7
movq %rax, %r14
leaq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
movq 0x30(%rbx), %r13
movq 0x38(%rbx), %rbx
callq 0x3f37d
leaq 0x20(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3f37d
leaq 0x30(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3f37d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rbf.c
// Function: distance_to_rbf_gaussian
double distance_to_rbf_gaussian(Instanceptr inst, int inputdim, double* mh)
{
	/*!Last Changed 19.08.2007*/
	int j;
	double sum;
	sum = 0.0;
	for (j = 0; j < inputdim; j++)
			sum += (real_feature(inst, j) - mh[j]) * (real_feature(inst, j) - mh[j]);
	return sum;
}

// Assembly:
testl %esi, %esi
jle 0x6e710
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r12d
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e4b6
subsd (%rbx,%r15,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e4b6
subsd (%rbx,%r15,8), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
cmpq %r15, %r12
jne 0x6e6b2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rbf.c
// Function: rbf_forward_propagation
void rbf_forward_propagation(Rbfnetworkptr network, Instanceptr inst, double* p, double* y)
{
	/*!Last Changed 19.08.2007*/
 double dist, s_h;
	int i, h;
	p[0] = 1.0;
	for (h = 1; h < network->hidden + 1; h++)
  {
   dist = distance_to_rbf_gaussian(inst, network->input, network->weights.m.values[h - 1]);
   s_h = network->weights.s.values[0][h - 1];
			p[h] = safeexp(-dist / (2 * s_h * s_h));
  }
	for (i = 0; i < network->output; i++)
	 {
		 y[i] = 0.0;
			for (h = 0; h < network->hidden + 1; h++)
				 y[i] += network->weights.w.values[i][h] * p[h];
	 }
	if (network->output > 1) /*For classification*/
  	softmax(y, network->output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdx)
movl (%rdi), %eax
testl %eax, %eax
jle 0x6e78f
movq %rsi, %r12
xorl %r13d, %r13d
movl 0x8(%r15), %esi
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
callq 0x6e693
movq 0x28(%r15), %rax
movq (%rax), %rax
movsd (%rax,%r13,8), %xmm1
xorpd 0x34a68(%rip), %xmm0    # 0xa31d0
movapd %xmm1, %xmm2
addsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x38e72
movsd %xmm0, 0x8(%r14,%r13,8)
movslq (%r15), %rax
incq %r13
cmpq %rax, %r13
jl 0x6e73f
movslq 0x4(%r15), %rsi
testq %rsi, %rsi
jle 0x6e7de
leal 0x1(%rax), %ecx
xorl %edx, %edx
movq $0x0, (%rbx,%rdx,8)
testl %eax, %eax
js 0x6e7d6
movq 0x38(%r15), %rdi
movq (%rdi,%rdx,8), %rdi
movsd (%rbx,%rdx,8), %xmm0
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm1
mulsd (%r14,%r8,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rdx,8)
incq %r8
cmpq %r8, %rcx
jne 0x6e7b9
incq %rdx
cmpq %rsi, %rdx
jne 0x6e79d
cmpl $0x2, %esi
jl 0x6e7f4
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5458c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rbf.c
// Function: real_actual_difference
double real_actual_difference(int output, Instanceptr inst, int classno, double* y)
{
	/*!Last Changed 19.08.2007*/
	double ri;
 if (output == 1)
			ri = give_regressionvalue(inst);
	else
			if (give_classno(inst) != classno)
				 ri = 0.0;
			else
					ri = 1.0;
	return ri - y[classno];
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
cmpl $0x1, %edi
jne 0x6e815
movq %rsi, %rdi
callq 0x2eaee
jmp 0x6e82f
movq %rsi, %rdi
callq 0x2eaca
cmpl %ebp, %eax
je 0x6e827
xorpd %xmm0, %xmm0
jmp 0x6e82f
movsd 0x33cf1(%rip), %xmm0    # 0xa2520
movslq %ebp, %rax
subsd (%rbx,%rax,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rbf.c
// Function: update_rbfweights
void update_rbfweights(Rbfnetworkptr network, Rbfweights delta, Rbfweights prevweights, Rbf_parameterptr params)
{
 /*!Last Changed 21.08.2007*/
 int i, h, j;
 for (i = 0; i < network->output; i++)
   for (h = 0; h < network->hidden + 1; h++)
     network->weights.w.values[i][h] = network->weights.w.values[i][h] + delta.w.values[i][h] + params->alpha * prevweights.w.values[i][h];
 for (h = 0; h < network->hidden; h++)
   for (j = 0; j < network->input; j++)
     network->weights.m.values[h][j] = network->weights.m.values[h][j] + delta.m.values[h][j] + params->alpha * prevweights.m.values[h][j];
 for (h = 0; h < network->hidden; h++)
   network->weights.s.values[0][h] = network->weights.s.values[0][h] + delta.s.values[0][h] + params->alpha * prevweights.s.values[0][h];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x60(%rsp), %rax
leaq 0x30(%rsp), %rcx
movslq 0x4(%rdi), %rdx
testq %rdx, %rdx
jle 0x6eb52
movl (%rdi), %r8d
movq 0x28(%rcx), %r9
movq 0x28(%rax), %r10
leal 0x1(%r8), %r11d
xorl %ebx, %ebx
testl %r8d, %r8d
js 0x6eb4a
movq 0x38(%rdi), %r14
movq (%r14,%rbx,8), %r14
movq (%r9,%rbx,8), %r15
movq (%r10,%rbx,8), %r12
xorl %r13d, %r13d
movsd (%r14,%r13,8), %xmm0
addsd (%r15,%r13,8), %xmm0
movsd 0x38(%rsi), %xmm1
mulsd (%r12,%r13,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r14,%r13,8)
incq %r13
cmpq %r13, %r11
jne 0x6eb21
incq %rbx
cmpq %rdx, %rbx
jne 0x6eb09
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0x6ebb2
movl 0x8(%rdi), %r8d
movq 0x8(%rcx), %r9
movq 0x8(%rax), %r10
xorl %r11d, %r11d
testl %r8d, %r8d
jle 0x6ebaa
movq 0x18(%rdi), %rbx
movq (%rbx,%r11,8), %rbx
movq (%r9,%r11,8), %r14
movq (%r10,%r11,8), %r15
xorl %r12d, %r12d
movsd (%rbx,%r12,8), %xmm0
addsd (%r14,%r12,8), %xmm0
movsd 0x38(%rsi), %xmm1
mulsd (%r15,%r12,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r8
jne 0x6eb81
incq %r11
cmpq %rdx, %r11
jne 0x6eb69
testl %edx, %edx
jle 0x6ebf7
movq 0x28(%rdi), %rdi
movq (%rdi), %rdi
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movq 0x18(%rax), %rax
movq (%rax), %rax
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm0
addsd (%rcx,%r8,8), %xmm0
movsd 0x38(%rsi), %xmm1
mulsd (%rax,%r8,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rdx
jne 0x6ebce
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rbf.c
// Function: test_rbfnetwork_cls
int test_rbfnetwork_cls(Rbfnetworkptr network, Instanceptr data)
{
	/*!Last Changed 19.08.2007*/
	double *p, *y;
	Instanceptr inst;
	int correct = 0, classno;
	p = safemalloc((network->hidden + 1) * sizeof(double), "test_rbfnetwork_cls", 3);
	y = safemalloc(network->output * sizeof(double), "test_rbfnetwork_cls", 4);
	inst = data;
	while (inst)
	 {
		 rbf_forward_propagation(network, inst, p, y);
			classno = findMaxOutput(y, network->output);
			if (classno == give_classno(inst))
				 correct++;
		 inst = inst->next;
	 }
	safe_free(p);
	safe_free(y);
	return correct;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rax
leaq 0x8(,%rax,8), %rdi
leaq 0x3da39(%rip), %r12     # 0xac65d
movq %r12, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r15
movslq 0x4(%r14), %rdi
shlq $0x3, %rdi
movq %r12, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r12
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x6ec8b
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x6e714
movl 0x4(%r14), %esi
movq %r12, %rdi
callq 0x37852
movl %eax, %r13d
movq %rbx, %rdi
callq 0x2eaca
xorl %ecx, %ecx
cmpl %eax, %r13d
sete %cl
addl %ecx, %ebp
movq 0x10(%rbx), %rbx
jmp 0x6ec4e
movq %r15, %rdi
callq 0x39194
movq %r12, %rdi
callq 0x39194
movl %ebp, %eax
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/rbf.c
// Function: test_rbfnetwork_reg
double test_rbfnetwork_reg(Rbfnetworkptr network, Instanceptr data)
{
	/*!Last Changed 19.08.2007*/
	double *p, *y, squaredError = 0.0;
	Instanceptr inst;
	p = safemalloc((network->hidden + 1) * sizeof(double), "test_rbfnetwork_reg", 3);
	y = safemalloc(sizeof(double), "test_rbfnetwork_reg", 4);
	inst = data;
	while (inst)
	 {
		 rbf_forward_propagation(network, inst, p, y);
			squaredError += (y[0] - give_regressionvalue(inst)) * (y[0] - give_regressionvalue(inst));
		 inst = inst->next;
	 }
	safe_free(p);
	safe_free(y);
	return squaredError;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rax
leaq 0x8(,%rax,8), %rdi
leaq 0x3d63c(%rip), %r12     # 0xac686
movq %r12, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r15
movl $0x8, %edi
movq %r12, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r12
xorpd %xmm0, %xmm0
testq %rbx, %rbx
je 0x6f0ef
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x6e714
movsd (%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2eaee
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd (%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x2eaee
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x6f07d
jmp 0x6f0f4
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x39194
movq %r12, %rdi
callq 0x39194
movsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: print_regression_results
void print_regression_results(Instanceptr testdata, Regressionresultptr result, double runtime, int printbinary, int displayruntime)
{
 /*!Last Changed 25.05.2006 added regression value*/
	/*!Last Changed 13.12.2004 added printbinary*/
 /*!Last Changed 10.03.2004*/
	char pst[READLINELENGTH], pst2[READLINELENGTH];
	int i;
 double regvalue;
 Instanceptr tmp;
	if (printbinary)
	 {
   set_precision(pst, NULL, "\n");
   set_precision(pst2, NULL, " ");
   tmp = testdata;
		 for (i = 0; i < result->datasize; i++)
    {
     regvalue = give_regressionvalue(tmp);
     fprintf(output, "%d ", tmp->index);
     fprintf(output, pst2, regvalue);
     fprintf(output, pst, result->absoluteerrors[i]);
     tmp = tmp->next;
    }
	 }
	else
  	if (displayruntime)
			 {
				 set_precision(pst, NULL, " %.3lf\n");
	  		fprintf(output, pst, result->regressionperformance / result->datasize, runtime); 		 
			 }
	  else
			 {
				 set_precision(pst, NULL, "\n");
		  	fprintf(output, pst, result->regressionperformance / result->datasize); 		 
			 }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf4258, %rsp          # imm = 0xF4258
movq %rsi, %rbx
testl %edx, %edx
je 0x70acd
movq %rdi, %r14
leaq 0x35745(%rip), %rdx     # 0xa616b
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x39529
leaq 0x34c54(%rip), %rdx     # 0xa568d
leaq 0x7a130(%rsp), %rdi
xorl %esi, %esi
callq 0x39529
cmpl $0x0, 0x10(%rbx)
jle 0x70b4f
leaq 0x33e64f(%rip), %rbp    # 0x3af0a8
leaq 0x7a130(%rsp), %r12
leaq 0x10(%rsp), %r13
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2eaee
movsd %xmm0, 0x8(%rsp)
movq (%rbp), %rdi
movl 0x18(%r14), %edx
leaq 0x3c227(%rip), %rsi     # 0xaccad
xorl %eax, %eax
callq 0x42e0
movq (%rbp), %rdi
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
movq (%rbp), %rdi
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x10(%r14), %r14
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x70a69
jmp 0x70b4f
testl %ecx, %ecx
je 0x70b17
leaq 0x3235b(%rip), %rdx     # 0xa2e33
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x39529
leaq 0x33e5b4(%rip), %rax    # 0x3af0a8
movq (%rax), %rdi
movsd 0x8(%rbx), %xmm0
cvtsi2sdl 0x10(%rbx), %xmm1
divsd %xmm1, %xmm0
movq %r14, %rsi
movsd 0x8(%rsp), %xmm1
movb $0x2, %al
callq 0x42e0
jmp 0x70b4f
leaq 0x3564d(%rip), %rdx     # 0xa616b
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x39529
leaq 0x33e574(%rip), %rax    # 0x3af0a8
movq (%rax), %rdi
movsd 0x8(%rbx), %xmm0
cvtsi2sdl 0x10(%rbx), %xmm1
divsd %xmm1, %xmm0
movq %r14, %rsi
movb $0x1, %al
callq 0x42e0
addq $0xf4258, %rsp          # imm = 0xF4258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: performance_initialize_regression
Regressionresultptr performance_initialize_regression(int datasize)
{
	/*!Last Changed 13.12.2004*/
 Regressionresultptr result;
 result = safemalloc(sizeof(Regressionresult), "performance_initialize_regression", 2);
	result->regressionperformance = 0;
 result->absoluteerrors = safemalloc(datasize * sizeof(double), "performance_initialize_regression", 4);
 result->datasize = datasize;
 result->epsilonloss = 0.0;
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x3be27(%rip), %r14     # 0xac999
movl $0x20, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r15
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
movslq %ebx, %rbx
leaq (,%rbx,8), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, (%r15)
movl %ebx, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_onefeature
void* train_onefeature(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	/*!Last Changed 11.08.2005 added model for onefeature algorithm*/
	/*!Last Changed 10.12.2004*/
	char dummy;
 Model_onefeatureptr m;
	Instanceptr leftgroup = NULL, rightgroup = NULL;
	m = safemalloc(sizeof(Model_onefeature), "train_onefeature", 4);
	m->bestfeature = best_regression_feature(*trdata, &(m->bestsplit), &dummy);
	divide_instancelist_according_to_split(trdata, &leftgroup, &rightgroup, m->bestfeature, m->bestsplit);
	m->leftmean = find_mean_of_regression_value(leftgroup);
	m->rightmean = find_mean_of_regression_value(rightgroup);
	deallocate(leftgroup);
	deallocate(rightgroup);
	return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
xorl %eax, %eax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x3bdbf(%rip), %rsi     # 0xac9bb
movl $0x20, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
movq (%r12), %rdi
leaq 0x8(%rax), %rsi
leaq 0x7(%rsp), %rdx
callq 0x753a6
movl %eax, (%r15)
movsd 0x8(%r15), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x301e1
movq (%r14), %rdi
callq 0x2f6a1
movsd %xmm0, 0x10(%r15)
movq (%rbx), %rdi
callq 0x2f6a1
movsd %xmm0, 0x18(%r15)
movq (%r14), %rdi
callq 0x2f616
movq (%rbx), %rdi
callq 0x2f616
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: test_knnreg
Prediction test_knnreg(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 19.04.2004*/
	/*!Last Changed 10.03.2004*/
	int i;
	Prediction predicted;
	Instanceptr *nearestneighbors, trdata;
	Knn_parameterptr p;
 p = (Knn_parameterptr) parameters;
	trdata = (Instanceptr) model;
 if (current_dataset->storetype == STORE_KERNEL)
   nearestneighbors = find_all_neighbors(trdata, data, &(p->nearcount));
 else
	  nearestneighbors = find_nearest_neighbors(trdata, data, p->nearcount);
	predicted.regvalue = 0;
 for (i = 0; i < p->nearcount; i++)
			predicted.regvalue += give_regressionvalue(nearestneighbors[i]);
	predicted.regvalue /= p->nearcount;
	safe_free(nearestneighbors);
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rax
movq %rdi, %rbx
leaq 0x61bbc(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
cmpl $0x3, 0x140713c(%rcx)
jne 0x70ccd
movq %rax, %rdi
movq %r14, %rdx
callq 0x30b9c
jmp 0x70cd8
movl (%r14), %edx
movq %rax, %rdi
callq 0x30ca9
movq %rax, %r15
movq $0x0, (%rbx)
movl (%r14), %eax
xorpd %xmm1, %xmm1
testl %eax, %eax
jle 0x70d12
xorl %r12d, %r12d
movsd %xmm1, (%rsp)
movq (%r15,%r12,8), %rdi
callq 0x2eaee
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x70cf0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movq %r15, %rdi
callq 0x39194
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_regstump
void* train_regstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Regressionnodeptr regtreenode;
	Regtree_parameterptr p;
	p = (Regtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->cvinstances = *trdata;
 regtreenode->instances = *trdata;
	regtreenode->featureno = best_hybrid_regression_tree_split(regtreenode, p);
 make_regression_children(regtreenode, p->leaftype);
 setup_regressionnode_properties(regtreenode->left, p->leaftype);
 setup_regressionnode_properties(regtreenode->right, p->leaftype);
 make_leaf_regression_node(regtreenode->left, p->leaftype);
 make_leaf_regression_node(regtreenode->right, p->leaftype);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdx), %edx
xorl %edi, %edi
movl $0x1, %esi
callq 0x7580b
movq %rax, %r15
movq (%rbx), %rax
movq %rax, 0x28(%r15)
movq (%rbx), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x76b7b
movl %eax, 0x68(%r15)
movl (%r14), %esi
movq %r15, %rdi
callq 0x759f8
movq (%r15), %rdi
movl (%r14), %esi
callq 0x75dad
movq 0x8(%r15), %rdi
movl (%r14), %esi
callq 0x75dad
movq (%r15), %rdi
movl (%r14), %esi
callq 0x74df3
movq 0x8(%r15), %rdi
movl (%r14), %esi
callq 0x74df3
movq $0x0, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: test_regressiontree
Prediction test_regressiontree(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 06.03.2005*/
	/*!Last Changed 09.12.2004*/
	Regressionnodeptr regtreenode;
 Prediction predicted;
	regtreenode = (Regressionnodeptr) model;
 while (regtreenode->featureno != -1)
   regtreenode = next_regression_node(regtreenode, data); 
 if (regtreenode->leaftype == CONSTANTLEAF)
   predicted.regvalue = regtreenode->regressionvalue;
 else
   predicted.regvalue = linear_fit_value(regtreenode->w, data);
 return predicted;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x68(%rdx)
je 0x70dec
movq %rax, %rdi
movq %r14, %rsi
callq 0x75873
cmpl $-0x1, 0x68(%rax)
jne 0x70ddb
cmpl $0x0, 0x6c(%rax)
je 0x70e04
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
movq %r14, %rdx
callq 0x75608
jmp 0x70e09
movsd 0x70(%rax), %xmm0
movsd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_softregstump
void* train_softregstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Regressionnodeptr regtreenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->weight = 1.0;
 regtreenode->instances = *trdata;
 if (p->leaftype == CONSTANTLEAF)
   regtreenode->regressionvalue = produce_random_value(-0.01, +0.01);
 else
   regtreenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
 regtreenode->cvinstances = NULL;
 find_best_soft_regtree_split(regtreenode, regtreenode, *trdata, p);
 make_leaf_regression_node(regtreenode->left, p->leaftype);
 make_leaf_regression_node(regtreenode->right, p->leaftype);
 if (regtreenode->featureno != LEAF_NODE)
   deallocate(regtreenode->instances);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
movl (%rdx), %edx
xorl %edi, %edi
movl $0x1, %esi
callq 0x7580b
movq %rax, %r14
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x48(%r14)
movq (%rbx), %rax
movq %rax, 0x20(%r14)
cmpl $0x0, (%r15)
je 0x70e83
leaq 0x61a1a(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x1c0(%rax), %edi
movsd 0x31f51(%rip), %xmm0    # 0xa2db8
movsd 0x31f51(%rip), %xmm1    # 0xa2dc0
movl $0x1, %esi
callq 0x3dd75
movq %rax, 0x30(%r14)
movq %rdx, 0x38(%r14)
jmp 0x70e9e
movsd 0x31f2d(%rip), %xmm0    # 0xa2db8
movsd 0x31f2d(%rip), %xmm1    # 0xa2dc0
callq 0x39f62
movsd %xmm0, 0x70(%r14)
movq $0x0, 0x28(%r14)
movq (%rbx), %rdx
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x88708
movq (%r14), %rdi
movl (%r15), %esi
callq 0x74df3
movq 0x8(%r14), %rdi
movl (%r15), %esi
callq 0x74df3
cmpl $-0x1, 0x68(%r14)
je 0x70ede
movq 0x20(%r14), %rdi
callq 0x2f616
movq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_regressiontree
void* train_regressiontree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 25.05.2006 added in_list ...*/
	/*!Last Changed 06.03.2005*/
	/*!Last Changed 09.12.2004*/
	Regressionnodeptr regtreenode;
	Regtree_parameterptr p;
	p = (Regtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->cvinstances = *cvdata;
 regtreenode->instances = *trdata;
	create_regtree(regtreenode, p);
 if (in_list(p->modelselectionmethod, 3, MODEL_SELECTION_CV, MODEL_SELECTION_AIC, MODEL_SELECTION_BIC) || p->prunetype == VALIDATIONPRUNING)
  	prune_regression_tree(regtreenode, p);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl (%rdx), %edx
xorl %edi, %edi
movl $0x1, %esi
callq 0x7580b
movq %rax, %r15
movq (%r12), %rax
movq %rax, 0x28(%r15)
movq (%rbx), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x76c1c
movl 0x8(%r14), %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x2, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
jne 0x70f7c
cmpl $0x1, 0x4(%r14)
jne 0x70f87
movq %r15, %rdi
movq %r14, %rsi
callq 0x75c0b
movq $0x0, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_softregressiontree
void* train_softregressiontree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Regressionnodeptr regtreenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->weight = 1.0;
 regtreenode->instances = *trdata;
 if (p->leaftype == CONSTANTLEAF)
   regtreenode->regressionvalue = produce_random_value(-0.01, +0.01);
 else
   regtreenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
 create_softregtree(regtreenode, regtreenode, *cvdata, p);
 if (regtreenode->featureno != LEAF_NODE)
   deallocate(regtreenode->instances);
 deallocate(*cvdata);
	*trdata = NULL;
	return regtreenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %edx
xorl %edi, %edi
movl $0x1, %esi
callq 0x7580b
movq %rax, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x48(%r15)
movq (%rbx), %rax
movq %rax, 0x20(%r15)
cmpl $0x0, (%r12)
je 0x7100f
leaq 0x6188e(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x1c0(%rax), %edi
movsd 0x31dc5(%rip), %xmm0    # 0xa2db8
movsd 0x31dc5(%rip), %xmm1    # 0xa2dc0
movl $0x1, %esi
callq 0x3dd75
movq %rax, 0x30(%r15)
movq %rdx, 0x38(%r15)
jmp 0x7102a
movsd 0x31da1(%rip), %xmm0    # 0xa2db8
movsd 0x31da1(%rip), %xmm1    # 0xa2dc0
callq 0x39f62
movsd %xmm0, 0x70(%r15)
movq (%r14), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x88ba1
cmpl $-0x1, 0x68(%r15)
je 0x7104b
movq 0x20(%r15), %rdi
callq 0x2f616
movq (%r14), %rdi
callq 0x2f616
movq $0x0, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_svmregtree
void* train_svmregtree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 01.11.2009*/
 Regressionnodeptr regtreenode;
 Regtree_parameterptr p;
 p = (Regtree_parameterptr) parameters;
 regtreenode = createnewregnode(NULL, 1, p->leaftype);
 regtreenode->cvinstances = *cvdata;
 regtreenode->instances = *trdata;
 create_svmregtree(regtreenode, p);
 if (in_list(p->modelselectionmethod, 3, MODEL_SELECTION_CV, MODEL_SELECTION_AIC, MODEL_SELECTION_BIC) || p->prunetype == VALIDATIONPRUNING)
   prune_regression_tree(regtreenode, p);
 *trdata = NULL;
 return regtreenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl (%rdx), %edx
xorl %edi, %edi
movl $0x1, %esi
callq 0x7580b
movq %rax, %r15
movq (%r12), %rax
movq %rax, 0x28(%r15)
movq (%rbx), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x92168
movl 0x8(%r14), %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x2, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
jne 0x710cd
cmpl $0x1, 0x4(%r14)
jne 0x710d8
movq %r15, %rdi
movq %r14, %rsi
callq 0x75c0b
movq $0x0, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_mlpgenericreg
void* train_mlpgenericreg(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	/*!Last Changed 08.12.2004 added matrix_free(cv)*/
	Mlpparameters mlpparams;
 Mlpnetworkptr neuralnetwork;
	matrix train, cv;
	neuralnetwork = safemalloc(sizeof(Mlpnetwork), "train_mlpgenericreg", 4);
 mlpparams = *((Mlpparametersptr) parameters);
	mlpparams.inputnum = data_size(*trdata);
	mlpparams.trnum = mlpparams.inputnum;
	mlpparams.cvnum = data_size(*cvdata);
	train = instancelist_to_matrix(*trdata, REGRESSION, -1, MULTIVARIATE_LINEAR);
	cv = instancelist_to_matrix(*cvdata, REGRESSION, -1, MULTIVARIATE_LINEAR);
	*neuralnetwork = mlpn_general(train, cv, &mlpparams, REGRESSION);
	matrix_free(train);
	matrix_free(cv);
	return neuralnetwork;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
leaq 0x3b843(%rip), %rsi     # 0xac9d8
movl $0x98, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x2fa14
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq (%r15), %rdi
callq 0x2fa14
movl %eax, 0xc(%r14)
movq (%r12), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x2f755
movq %rax, %r12
movq %rdx, %r13
movq (%r15), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x2f755
movq %rax, %r15
movq %rdx, %rbp
movl $0x1, (%rsp)
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x42ac4
movl $0x98, %edx
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4310
movq %r12, %rdi
movq %r13, %rsi
callq 0x3dbad
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3dbad
movq %r14, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: test_mlpgenericreg
Prediction test_mlpgenericreg(Instanceptr data, void* model, void* parameters, double* posterior)
{
	/*!Last Changed 08.12.2004 added matrix_free(cv)*/
 Mlpnetwork neuralnetwork;
	matrix test, testY, output_error;
 Prediction predicted;
 neuralnetwork = *((Mlpnetworkptr) model);
 output_error = matrix_alloc(1, 1);
	test = instancelist_to_matrix(data, REGRESSION, -1, MULTIVARIATE_LINEAR);
 testMlpnInput_reg(test.values[0], &testY, neuralnetwork, &output_error);
 matrix_free(output_error);
 matrix_free(testY);
	matrix_free(test);
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdx, %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb8(%rsp), %r14
movl $0x98, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4310
movl $0x1, %edi
movl $0x1, %esi
callq 0x3c6e5
leaq 0x98(%rsp), %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq %r15, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x2f755
movq %rax, %r15
movq %rdx, %r13
movq (%rdx), %rax
movl $0x13, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x45213
movq (%r12), %rdi
movq 0x8(%r12), %rsi
callq 0x3dbad
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x3dbad
movq %r15, %rdi
movq %r13, %rsi
callq 0x3dbad
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/regression.c
// Function: train_dncreg
void* train_dncreg(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 16.04.2007*/
 Mlpparameters mlpparams;
 Mlpnetworkptr neuralnetwork;
 matrix train;
 neuralnetwork = safemalloc(sizeof(Mlpnetwork), "train_dncreg", 4);
 mlpparams = *((Mlpparametersptr) parameters);
 mlpparams.inputnum = data_size(*trdata);
 mlpparams.trnum = mlpparams.inputnum;
 train = instancelist_to_matrix(*trdata, REGRESSION, -1, MULTIVARIATE_LINEAR);
 *neuralnetwork = dnc_reg(train, &mlpparams);
 matrix_free(train);
 return neuralnetwork;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdx, %r15
movq %rdi, %r12
leaq 0x3b685(%rip), %rsi     # 0xac9ec
movl $0x98, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x2fa14
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq (%r12), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x2f755
movq %rax, %r15
movq %rdx, %r12
leaq 0x98(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x45bca
movl $0x98, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4310
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dbad
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq