LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: number_of_free_parameters_of_hessian
double number_of_free_parameters_of_hessian(double* eigenvalues, int weightcount, double alpha)
{
	/*!Last Changed 26.06.2005*/
	double sum = 0;
	int i;
	for (i = 0; i < weightcount; i++)
		 sum += eigenvalues[i] / (eigenvalues[i] + alpha);
	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x65c9f
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
addsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x65c5f
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: hinge_loss
double hinge_loss(double y, double fx)
{
 HINGELOSS_TYPE hingelosstype = get_parameter_l("hingelosstype");
 if (1 - y * fx > 0.0)
   switch (hingelosstype)
    {
     case REGULAR_LOSS:return 1 - y * fx;
     case HINGELOSS_01:if (1 - y * fx < 1.0)
                         return 1 - y * fx;
                       else
                         return 1.0;
     case HINGELOSS_02:if (1 - y * fx < 2.0)
                         return 1 - y * fx;
                       else
                         return 2.0;
    } 
 return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
leaq 0x81277(%rip), %rdi     # 0xe6f40
callq 0x792b0
movl %eax, -0x1c(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x7c31a(%rip), %xmm1    # 0xe2018
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x65e85
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x65d36
jmp 0x65d1b
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x65d71
jmp 0x65d25
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x65dfd
jmp 0x65e83
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x7c2b5(%rip), %xmm1    # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x65e8d
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm0, %xmm1
movsd 0x7c27a(%rip), %xmm0    # 0xe2018
addsd %xmm0, %xmm1
movsd 0x7c26e(%rip), %xmm0    # 0xe2018
ucomisd %xmm1, %xmm0
jbe 0x65deb
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x7c23b(%rip), %xmm1    # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x65e8d
movsd 0x7c225(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x8(%rbp)
jmp 0x65e8d
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm0, %xmm1
movsd 0x7c1ee(%rip), %xmm0    # 0xe2018
addsd %xmm0, %xmm1
movsd 0x7ce6a(%rip), %xmm0    # 0xe2ca0
ucomisd %xmm1, %xmm0
jbe 0x65e74
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x7c1af(%rip), %xmm1    # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x65e8d
movsd 0x7ce24(%rip), %xmm0    # 0xe2ca0
movsd %xmm0, -0x8(%rbp)
jmp 0x65e8d
jmp 0x65e85
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: srm_epsilon
double srm_epsilon(int h, int N, double a1, double a2)
{
	/*!Last Changed 22.01.2005*/
	double nom, denom, nu;
	nu = 0.01;
	nom = h * (log((a2 * N) / (h + 0.0)) + 1) - log (nu / 4.0);
	denom = N;
	return (a1 * nom) / denom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd 0x7a6b0(%rip), %xmm0    # 0xe2020
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x4120
movsd 0x7a66e(%rip), %xmm1    # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x7b0c0(%rip), %xmm1    # 0xe2a80
divsd %xmm1, %xmm0
callq 0x4120
movsd -0x40(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl -0x8(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: srm_regression
double srm_regression(double error, int h, int N, double a1, double a2)
{
	/*!Last Changed 22.01.2005*/
	double epsilon, upperbound;
	int c;
	c = 1;
	epsilon = srm_epsilon(h, N, a1, a2);
	upperbound = error / (1 - c * sqrt(epsilon));
	return upperbound;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movl $0x1, -0x34(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x67950
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x34(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x42a0
movsd -0x48(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
movsd 0x7a4bc(%rip), %xmm2    # 0xe2018
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: search_and_add_candidate_model
void search_and_add_candidate_model(char** filenames, char* directory, int model, int* models, int* filecount)
{
	/*!Last Changed 02.06.2004*/
	int i;
	char filename[READLINELENGTH];
	for (i = 0; i < *filecount; i++)
		 if (models[i] == model)
				 break;
	if (i == *filecount)
	 {
		 (*filecount)++;
			sprintf(filename,"%s-%d.txt", directory, model);
			strcpy(filenames[(*filecount) - 1], filename); 
   models[(*filecount) - 1] = model;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x67c0f
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x67c02
jmp 0x67c0f
jmp 0x67c04
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x67be5
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x67c77
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x7a150(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0x7f415(%rip), %rsi     # 0xe704f
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x7a150(%rbp), %rsi
callq 0x4220
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: hmm_add_candidate_model
void hmm_add_candidate_model(char** filenames, char* directory, int index, Hmm_modelptr models, int* models_searched, int* filecount)
{
 /*!Last Changed 02.06.2004*/
 char filename[READLINELENGTH];
 (*filecount)++;
 models[index].tried = BOOLEAN_TRUE;
 models_searched[(*filecount) - 1] = index;
 sprintf(filename,"%s/%dM%dS.txt", directory, models[index].mixture, models[index].states);
 strcpy(filenames[(*filecount) - 1], filename); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x10(%rax)
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
leaq -0x7a150(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rsi
imulq $0x14, %rsi, %rsi
addq %rsi, %rax
movl (%rax), %r8d
leaq 0x7f285(%rip), %rsi     # 0xe6f94
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x7a150(%rbp), %rsi
callq 0x4220
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: compare_two_hmm_models
int compare_two_hmm_models(char** two_file, char* simulationdirectory, Hmm_model model1, Hmm_model model2)
{
 /*!Last Changed 10.01.2009*/
 int dummy;
 double confidence = 1 - get_parameter_f("confidencelevel"), conf;
 if (model1.index < model2.index)
  {
   sprintf(two_file[0], "%s/%dM%dS.txt", simulationdirectory, model1.mixture, model1.states);
   sprintf(two_file[1], "%s/%dM%dS.txt", simulationdirectory, model2.mixture, model2.states);
  }
 else
  {
   sprintf(two_file[0], "%s/%dM%dS.txt", simulationdirectory, model2.mixture, model2.states);
   sprintf(two_file[1], "%s/%dM%dS.txt", simulationdirectory, model1.mixture, model1.states);
  }
 return compare_two_files_using_test(get_parameter_l("testtype"), two_file, &dummy, confidence, &conf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x795d6(%rip), %rdi     # 0xe269d
callq 0x79040
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movaps %xmm0, %xmm1
movsd 0x78f39(%rip), %xmm0    # 0xe2018
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
jge 0x69139
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rdx
movl 0x4(%rax), %ecx
movl (%rax), %r8d
leaq 0x7de88(%rip), %rsi     # 0xe6f94
movb $0x0, %al
callq 0x4170
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rdx
movl 0x4(%rax), %ecx
movl (%rax), %r8d
leaq 0x7de64(%rip), %rsi     # 0xe6f94
movb $0x0, %al
callq 0x4170
jmp 0x69180
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rdx
movl 0x4(%rax), %ecx
movl (%rax), %r8d
leaq 0x7de3f(%rip), %rsi     # 0xe6f94
movb $0x0, %al
callq 0x4170
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rdx
movl 0x4(%rax), %ecx
movl (%rax), %r8d
leaq 0x7de1b(%rip), %rsi     # 0xe6f94
movb $0x0, %al
callq 0x4170
leaq 0x7de3a(%rip), %rdi     # 0xe6fc1
callq 0x792b0
movl %eax, %edi
movq -0x8(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
leaq -0x14(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0xc2810
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: compare_two_mlp_models
int compare_two_mlp_models(char** two_file, char* simulationdirectory, Datasetptr d, int model1, int model2)
{
	/*!Last Changed 17.07.2005*/
	int min, max, dummy;
	double confidence = 1 - get_parameter_f("confidencelevel"), conf;
	min = imin(model1, model2);
	max = model1 + model2 - min;
	sprintf(two_file[0], "%s/%s-%d.txt", simulationdirectory, d->name, min);
	sprintf(two_file[1], "%s/%s-%d.txt", simulationdirectory, d->name, max);
 return compare_two_files_using_test(get_parameter_l("testtype"), two_file, &dummy, confidence, &conf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
leaq 0x7920b(%rip), %rdi     # 0xe269d
callq 0x79040
movaps %xmm0, %xmm1
movsd 0x78b76(%rip), %xmm0    # 0xe2018
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x528e0
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x24(%rbp), %r8d
leaq 0x7db69(%rip), %rsi     # 0xe704c
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x28(%rbp), %r8d
leaq 0x7db43(%rip), %rsi     # 0xe704c
movb $0x0, %al
callq 0x4170
leaq 0x7daaa(%rip), %rdi     # 0xe6fc1
callq 0x792b0
movl %eax, %edi
movq -0x8(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
leaq -0x2c(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0xc2810
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: mlp_model_simulation_one_forward
int mlp_model_simulation_one_forward(Datasetptr d, char* simulationdirectory, int maxhidden, int starthidden, int* tries)
{
 /*!Last Changed 26.05.2006 added starthidden*/
	/*!Last Changed 16.07.2005*/
	char **two_file;
	int bestmodel;
 if (starthidden < 0 || starthidden > maxhidden)
   bestmodel = 0;
 else
   bestmodel = starthidden;
 two_file = (char**) safemalloc_2d(sizeof(char *), sizeof(char), 2, 500, "mlp_model_simulation_forward", 4);
	*tries = 1;
	while (bestmodel < maxhidden)
	 {
			(*tries)++;
			if (compare_two_mlp_models(two_file, simulationdirectory, d, bestmodel, bestmodel + 1) == 0)
				 break;
			bestmodel++;
	 }
	free_2d((void**)two_file, 2);
	return bestmodel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x69758
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x69761
movl $0x0, -0x2c(%rbp)
jmp 0x69767
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x8, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x1f4, %ecx            # imm = 0x1F4
leaq 0x7d8f8(%rip), %r8      # 0xe707a
movl $0x4, %r9d
callq 0x53120
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x697dc
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x2c(%rbp), %r8d
addl $0x1, %r8d
callq 0x69470
cmpl $0x0, %eax
jne 0x697d1
jmp 0x697dc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6979b
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x52e20
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: mlp_model_simulation_one_backward
int mlp_model_simulation_one_backward(Datasetptr d, char* simulationdirectory, int maxhidden, int starthidden, int* tries)
{
 /*!Last Changed 26.05.2006 added starthidden*/
	/*!Last Changed 16.07.2005*/
	char **two_file;
	int bestmodel;
 if (starthidden < 0 || starthidden > maxhidden)
   bestmodel = maxhidden;
 else
   bestmodel = starthidden;
 two_file = (char**) safemalloc_2d(sizeof(char *), sizeof(char), 2, 500, "mlp_model_simulation_backward", 4);
	*tries = 1;
	while (bestmodel > 0)
	 {
			(*tries)++;
			if (compare_two_mlp_models(two_file, simulationdirectory, d, bestmodel - 1, bestmodel) == 1)
				 break;
			bestmodel--;
	 }
	free_2d((void**)two_file, 2);
	return bestmodel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x69a28
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x69a30
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x69a36
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x8, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x1f4, %ecx            # imm = 0x1F4
leaq 0x7d668(%rip), %r8      # 0xe70b9
movl $0x4, %r9d
callq 0x53120
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
cmpl $0x0, -0x2c(%rbp)
jle 0x69aa8
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movl -0x2c(%rbp), %r8d
callq 0x69470
cmpl $0x1, %eax
jne 0x69a9d
jmp 0x69aa8
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x69a6a
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x52e20
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: hmm_model_simulation
Hmm_model hmm_model_simulation(MOST_SEARCH_TYPE simulation_algorithm, char* simulationdirectory, int maxstates, int maxmixture, int* tries)
{
 /*!Last Changed 10.01.2009*/
 switch (simulation_algorithm)
  {
   case MULTIMOST    :return hmm_model_simulation_multitest(simulationdirectory, maxstates, maxmixture, tries);
                      break;
   case ONE_FORWARD  :return hmm_model_simulation_one_forward(simulationdirectory, maxstates, tries);
                      break;
   case ONE_BACKWARD :return hmm_model_simulation_one_backward(simulationdirectory, maxstates, tries);
                      break;
   case FORWARD_MOST :return hmm_model_simulation_most(simulationdirectory, maxstates, maxmixture, tries, FORWARD);
                      break;
   case BACKWARD_MOST:return hmm_model_simulation_most(simulationdirectory, maxstates, maxmixture, tries, BACKWARD);
                      break;
   default           :printf(m1242, simulation_algorithm);
                      return hmm_model_simulation_multitest(simulationdirectory, maxstates, maxmixture, tries);
                      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x69b8a
movq -0x28(%rbp), %rax
leaq 0x7d3f2(%rip), %rcx     # 0xe6ef0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0x67d40
jmp 0x69bb2
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x69540
jmp 0x69bb2
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x69800
jmp 0x69bb2
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %r8
xorl %r9d, %r9d
callq 0x68bf0
jmp 0x69bb2
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %r8
movl $0x1, %r9d
callq 0x68bf0
jmp 0x69bb2
movl -0x4(%rbp), %esi
leaq 0x7d543(%rip), %rdi     # 0xe70d7
movb $0x0, %al
callq 0x4030
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0x67d40
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/model.c
// Function: mlp_model_simulation
int mlp_model_simulation(MOST_SEARCH_TYPE simulation_algorithm, char* datasetname, char* simulationdirectory, int maxhidden, int starthidden, int* tries)
{
	/*!Last Changed 16.07.2005*/
	Datasetptr d;
 d = search_dataset(Datasets, datasetname);
	if (d == NULL)
		 return 0;
	switch (simulation_algorithm)
	 {
	  case MULTIMOST    :return mlp_model_simulation_multitest(d, simulationdirectory, maxhidden, starthidden, tries);
				                  break;
			case ONE_FORWARD  :return mlp_model_simulation_one_forward(d, simulationdirectory, maxhidden, starthidden, tries);
				                  break;
			case ONE_BACKWARD :return mlp_model_simulation_one_backward(d, simulationdirectory, maxhidden, starthidden, tries);
				                  break;
			case FORWARD_MOST :return mlp_model_simulation_most(d, simulationdirectory, maxhidden, starthidden, tries, FORWARD);
				                  break;
			case BACKWARD_MOST:return mlp_model_simulation_most(d, simulationdirectory, maxhidden, starthidden, tries, BACKWARD);
				                  break;
   default           :printf(m1242, simulation_algorithm);
                      break;
	 }
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq 0x9bc63(%rip), %rax     # 0x105848
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1db80
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x69c08
movl $0x0, -0x4(%rbp)
jmp 0x69cdd
movl -0x8(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x69cc5
movq -0x38(%rbp), %rax
leaq 0x7d2e0(%rip), %rcx     # 0xe6f04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x68230
movl %eax, -0x4(%rbp)
jmp 0x69cdd
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x69730
movl %eax, -0x4(%rbp)
jmp 0x69cdd
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x69a00
movl %eax, -0x4(%rbp)
jmp 0x69cdd
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
xorl %r9d, %r9d
callq 0x691b0
movl %eax, -0x4(%rbp)
jmp 0x69cdd
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
movl $0x1, %r9d
callq 0x691b0
movl %eax, -0x4(%rbp)
jmp 0x69cdd
movl -0x8(%rbp), %esi
leaq 0x7d408(%rip), %rdi     # 0xe70d7
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: multiplicative_term_value
double multiplicative_term_value(Mtermptr term, double* featurevalues)
{
	/*!Last Changed 11.04.2005*/
	double value;
	switch (term->functiontype)
	 {
	  case FUNC_CONSTANT:return term->value;
				                  break;
			case FUNC_POWER   :value = featurevalues[term->featureindex - 1];
				                  if (term->power == 1)
											             return value; 
				                  else
											             return fpow(value, term->power);
										            break;
			case FUNC_SINUS   :
			case FUNC_COSINUS :value = additive_term_value(term->interm, featurevalues);
				                  if (term->functiontype == FUNC_SINUS)
											             value = sin(value);
										            else
											             value = cos(value);
										            if (term->power == 1)
											             return value;
										            else
											             return fpow(value, term->power);
										            break;
   default           :printf(m1235, term->functiontype);
                      break;
	 }
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x6acca
jmp 0x6acb0
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x6acdd
jmp 0x6acba
movl -0x24(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6ad2a
jmp 0x6ad96
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x6adb8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6ad10
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x6adb8
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x52840
movsd %xmm0, -0x8(%rbp)
jmp 0x6adb8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6add0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x6ad5b
movsd -0x20(%rbp), %xmm0
callq 0x42c0
movsd %xmm0, -0x20(%rbp)
jmp 0x6ad6a
movsd -0x20(%rbp), %xmm0
callq 0x40e0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6ad7f
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x6adb8
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x52840
movsd %xmm0, -0x8(%rbp)
jmp 0x6adb8
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x7c3e0(%rip), %rdi     # 0xe7184
movb $0x0, %al
callq 0x4030
movsd 0x77265(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: additive_term_value
double additive_term_value(Atermptr term, double* featurevalues)
{
	/*!Last Changed 11.04.2005*/
	Mtermptr tmp;
	double value = 1;
	tmp = term->start;
	while (tmp)
	 {
		 value *= multiplicative_term_value(tmp, featurevalues);
		 tmp = tmp->next;
	 }
	return value * term->sign;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd 0x77230(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ae25
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6ac90
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6adf9
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
mulsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: single_model_value
double single_model_value(Singlemodel m, double* featurevalues)
{
	/*!Last Changed 11.04.2005*/
	Atermptr tmp;
	double value = 0, noise;
	tmp = m.start;
	while (tmp)
	 {
		 value += additive_term_value(tmp, featurevalues);
		 tmp = tmp->next;
	 }
	noise = produce_normal_value(0, m.noiselevel);
	return value + noise;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6ae8f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6add0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6ae63
movq -0x28(%rbp), %rax
movsd 0x10(%rax), %xmm1
xorps %xmm0, %xmm0
callq 0xc4710
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: index_and_power_from_string
int index_and_power_from_string(char* st, int* power)
{
	/*!Last Changed 10.04.2005*/
	int i, len = strlen(st), pos = 0, index;
	char tmp[READLINELENGTH];
	strcpy(tmp, "");
	for (i = 1; i < len; i++)
		 if (st[i] == '^')
			 {
				 pos = 1;
     index = atoi(tmp);
	    strcpy(tmp, ""); 
			 }
			else
					sprintf(tmp, "%s%c", tmp, st[i]);
	if (pos == 0)
	 {
		 index = atoi(tmp);
			*power = 1;
	 }
	else
		 *power = atoi(tmp);
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a140, %rsp          # imm = 0x7A140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x7a140(%rbp), %rdi
leaq 0x82bc6(%rip), %rsi     # 0xedfda
callq 0x4220
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x6b499
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5e, %eax
jne 0x6b464
movl $0x1, -0x1c(%rbp)
leaq -0x7a140(%rbp), %rdi
callq 0x41c0
movl %eax, -0x20(%rbp)
leaq -0x7a140(%rbp), %rdi
leaq 0x82b7d(%rip), %rsi     # 0xedfda
callq 0x4220
jmp 0x6b48c
leaq -0x7a140(%rbp), %rdi
leaq -0x7a140(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
leaq 0x77d6b(%rip), %rsi     # 0xe31f0
movb $0x0, %al
callq 0x4170
jmp 0x6b48e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b420
cmpl $0x0, -0x1c(%rbp)
jne 0x6b4ba
leaq -0x7a140(%rbp), %rdi
callq 0x41c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x6b4ce
leaq -0x7a140(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
addq $0x7a140, %rsp          # imm = 0x7A140
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: interm_and_power_from_string
char* interm_and_power_from_string(char* st, int* power)
{
	/*!Last Changed 10.04.2005*/
	char* result = NULL, tmp[READLINELENGTH];
	int i, len = strlen(st);
	strcpy(tmp, "");
	for (i = 0; i < len; i++)
		 if (st[i] == '(')
			 {
				 if (strlen(tmp) != 0)
  				 *power = atoi(tmp);
					else
					  *power = 1;
    	strcpy(tmp, "");
			 }
			else
			  if (st[i] != ')')
						 sprintf(tmp, "%s%c", tmp, st[i]);
	result = strcopy(result, tmp);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movl %eax, -0x7a148(%rbp)
leaq -0x7a140(%rbp), %rdi
leaq 0x82ac2(%rip), %rsi     # 0xedfda
callq 0x4220
movl $0x0, -0x7a144(%rbp)
movl -0x7a144(%rbp), %eax
cmpl -0x7a148(%rbp), %eax
jge 0x6b5eb
movq -0x8(%rbp), %rax
movslq -0x7a144(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0x6b594
leaq -0x7a140(%rbp), %rdi
callq 0x4150
cmpq $0x0, %rax
je 0x6b575
leaq -0x7a140(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6b57f
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
leaq -0x7a140(%rbp), %rdi
leaq 0x82a4d(%rip), %rsi     # 0xedfda
callq 0x4220
jmp 0x6b5d5
movq -0x8(%rbp), %rax
movslq -0x7a144(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
je 0x6b5d3
leaq -0x7a140(%rbp), %rdi
leaq -0x7a140(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x7a144(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
leaq 0x77c24(%rip), %rsi     # 0xe31f0
movb $0x0, %al
callq 0x4170
jmp 0x6b5d5
jmp 0x6b5d7
movl -0x7a144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a144(%rbp)
jmp 0x6b527
movq -0x18(%rbp), %rdi
leaq -0x7a140(%rbp), %rsi
callq 0x54ba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: read_multiplicative_term_from_string
Mtermptr read_multiplicative_term_from_string(char* st)
{
	/*!Last Changed 10.04.2005*/
	Mtermptr result;
	char* termst;
	result = safemalloc(sizeof(Mterm), "read_multiplicative_term_from_string", 3);
	result->next = NULL;
	switch (st[0])
	 {
	  case 'x':result->functiontype = FUNC_POWER;
				        result->featureindex = index_and_power_from_string(&(st[1]), &(result->power));
												result->interm = NULL;
				        break;
			case 's':
			case 'c':if (st[0] == 's')
  				        result->functiontype = FUNC_SINUS;
				        else 
													 result->functiontype = FUNC_COSINUS;
												termst = interm_and_power_from_string(&(st[1]), &(result->power)); 
												result->interm = read_additive_term_from_string(termst);
												safe_free(termst);
				        break;
			default :result->functiontype = FUNC_CONSTANT;
				        result->value = atof(st);
												result->interm = NULL;
				        break;
	 }
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7bb8d(%rip), %rsi     # 0xe71b0
movl $0x28, %edi
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x63, %eax
je 0x6b6a1
jmp 0x6b653
movl -0x1c(%rbp), %eax
subl $0x73, %eax
je 0x6b6a1
jmp 0x6b65d
movl -0x1c(%rbp), %eax
subl $0x78, %eax
jne 0x6b6f9
jmp 0x6b66b
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
callq 0x6b3e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x6b722
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x73, %eax
jne 0x6b6ba
movq -0x10(%rbp), %rax
movl $0x2, 0x4(%rax)
jmp 0x6b6c5
movq -0x10(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
callq 0x6b4e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6b730
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x52e80
jmp 0x6b722
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x4100
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: read_additive_term_from_string
Atermptr read_additive_term_from_string(char* st)
{
	/*!Last Changed 10.04.2005*/
	Atermptr result;
	Mtermptr tmp, before;
	char** terms;
	int mulcount, i;
	result = safemalloc(sizeof(Aterm), "read_additive_term_from_string", 5);
	result->next = NULL;
	if (st[0] == '-')
		 result->sign = -1;
 else
		 result->sign = 1;
	if (st[0] == '+' || st[0] == '-')
	  terms = extract_multiplicative_terms(&(st[1]), &mulcount);
	else
   terms = extract_multiplicative_terms(st, &mulcount);
 result->start = read_multiplicative_term_from_string(terms[0]);
	before = result->start;
	for (i = 1; i < mulcount; i++)
	 {
		 tmp = read_multiplicative_term_from_string(terms[i]);
			before->next = tmp;
			before = tmp;
	 }
	free_2d((void**)terms, mulcount);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
leaq 0x7ba8d(%rip), %rsi     # 0xe71d5
movl $0x5, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6b77a
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x6b784
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x6b79c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6b7b3
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x6aec0
movq %rax, -0x28(%rbp)
jmp 0x6b7c4
movq -0x8(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x6aec0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x6b610
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x6b82a
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6b610
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6b7ee
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x52e20
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: read_single_model_from_string
void read_single_model_from_string(Singlemodelptr s, char* modelst)
{
	/*!Last Changed 10.04.2005*/
	int addcount, i;
	char** terms;
	Atermptr tmp, before;
 terms = extract_additive_terms(modelst, &addcount);
	s->start = read_additive_term_from_string(terms[0]);
	before = s->start;
 for (i = 1; i < addcount; i++)
	 {
		 tmp = read_additive_term_from_string(terms[i]);
			before->next = tmp;
			before = tmp;
	 }
	free_2d((void**)terms, addcount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x6b150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x6b730
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6b8c5
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6b730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6b889
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x52e20
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: free_additive_term
void free_additive_term(Atermptr a)
{
	/*!Last Changed 11.04.2005*/
	Mtermptr tmp, next;
	tmp = a->start;
	while (tmp)
	 {
		 next = tmp->next;
			free_multiplicative_term(tmp);
			safe_free(tmp);
			tmp = next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6bba7
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6bb20
movq -0x10(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x6bb78
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: free_single_model
void free_single_model(Singlemodel s)
{
	/*!Last Changed 11.04.2005*/
	Atermptr tmp, next;
 tmp = s.start;
	while (tmp)
	 {
		 next = tmp->next;
			free_additive_term(tmp);
			safe_free(tmp);
			tmp = next;
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6bbf2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6bb60
movq -0x8(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6bbc3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: free_multiple_model
void free_multiple_model(Multiplemodelptr m)
{
	/*!Last Changed 11.04.2005*/
	int i;
	safe_free(m->min);
	safe_free(m->max);
	for (i = 0; i < m->modelcount; i++)
		 free_single_model(m->models[i]);
	safe_free(m->models);
	safe_free(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6bc74
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x6bbb0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6bc2d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: data_count_of_multiple_model
int data_count_of_multiple_model(Multiplemodelptr m)
{
	/*!Last Changed 11.04.2005*/
	int result = 0, i;
	for (i = 0; i < m->modelcount; i++)
		 result += m->models[i].datacount;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6bcd8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6bca6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: generate_data_from_single_model
matrix generate_data_from_single_model(Singlemodel s, int featurecount, double* min, double* max)
{
	/*!Last Changed 11.04.2005*/
	int i, j;
	matrix result;
	result = matrix_alloc(s.datacount, featurecount + 1);
	for (i = 0; i < s.datacount; i++)
	 {
		 for (j = 0; j < featurecount; j++)
				 result.values[i][j] = produce_random_value(min[j], max[j]);
			result.values[i][j] = single_model_value(s, result.values[i]);
	 }
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl 0x8(%rax), %edi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x57fc0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6bdd7
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6bd86
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x545a0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6bd3f
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x6ae40
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6bd28
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: generate_data_from_multiple_model
matrix generate_data_from_multiple_model(Multiplemodelptr m)
{
	/*!Last Changed 11.04.2005*/
	matrix result;
	int datacount, i, j, k, p;
 datacount = data_count_of_multiple_model(m);
	result = matrix_alloc(datacount, m->featurecount + 1);
	k = 0;
	for (i = 0; i < m->modelcount; i++)
		 for (j = 0; j < m->models[i].datacount; j++)
			 {
		   for (p = 0; p < m->featurecount; p++)
				   result.values[k][p] = produce_random_value(m->min[p], m->max[p]);
     result.values[k][p] = single_model_value(m->models[i], result.values[k]);
			  k++;
			 }
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6bc90
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
addl $0x1, %esi
callq 0x57fc0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6bf47
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x20(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0x6bf37
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6becf
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x545a0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6be7c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x6ae40
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6be57
jmp 0x6bf39
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6be40
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multiplemodel.c
// Function: remove_instances_according_to_threshold
void remove_instances_according_to_threshold(Instanceptr* parentlist, Instanceptr* removed, double threshold, matrix w, char which)
{
	/*!Last Changed 11.04.2005*/
	double value;
	Instanceptr last, tmp, before, next;
	last = *removed;
	if (last)
		 while (last->next != NULL)
				 last = last->next;
	tmp = *parentlist;
	before = NULL;
	while (tmp)
	 {
		 next = tmp->next;
		 value = fabs(linear_fit_value(w, tmp) - give_regressionvalue(tmp));
			if ((value > threshold && which == '>') || (value < threshold && which == '<'))
			 {
				 if (last)
  				 last->next = tmp;
					else
						 *removed = tmp;
					last = tmp;
					if (before)
						 before->next = tmp->next;
					else
						 *parentlist = tmp->next;
			 }
			else
				 before = tmp;
			tmp = next;
	 }
	last->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x6bfb2
jmp 0x6bf97
movq -0x40(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6bfb0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x6bf97
jmp 0x6bfb2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x6c0ac
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xa6aa0
movsd %xmm0, -0x60(%rbp)
movq -0x48(%rbp), %rdi
callq 0x43580
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
subsd %xmm1, %xmm0
movaps 0x76e52(%rip), %xmm1    # 0xe2e60
pand %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x6c02c
movsbl -0x29(%rbp), %eax
cmpl $0x3e, %eax
je 0x6c045
movsd -0x38(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6c097
movsbl -0x29(%rbp), %eax
cmpl $0x3c, %eax
jne 0x6c097
cmpq $0x0, -0x40(%rbp)
je 0x6c05a
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x6c065
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x6c086
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x6c095
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6c09f
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x6bfc5
movq -0x40(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
nop