LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/krule.c
// Function: find_best_discrete_condition_3
void find_best_discrete_condition_3(Korderingsplit* split, int* rangelist, int* iter, int** featurecounts, int partitioncounts[], int positive, double* bestgain)
{
 int* perm[3];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     perm[2] = first_permutation(rangelist[2]);
     do{
       update_best_discrete_condition(split, perm, rangelist, iter, featurecounts, partitioncounts, bestgain);
     }while (next_permutation(perm[2], rangelist[2]));
     safe_free(perm[2]);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rsi, 0x8(%rsp)
movl (%rsi), %edi
callq 0x3873a
leaq 0x50(%rsp), %r14
movq %rax, 0x10(%rsp)
movq %rax, (%r14)
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %rbx
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %r12
movq 0x8(%rsp), %rbp
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x3873a
movq %rax, 0x18(%rsp)
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x3873a
movq %rax, 0x20(%rsp)
movq %rax, 0x60(%rsp)
movq %r13, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq 0x48(%rsp), %r9
callq 0x314e3
movl 0x8(%rbp), %esi
movq 0x20(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x31856
movq 0x20(%rsp), %rdi
callq 0x39194
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x3183f
movq 0x18(%rsp), %rdi
callq 0x39194
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x10(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x31828
movq 0x10(%rsp), %rdi
addq $0x68, %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/krule.c
// Function: find_best_discrete_condition_4
void find_best_discrete_condition_4(Korderingsplit* split, int* rangelist, int* iter, int** featurecounts, int partitioncounts[], int positive, double* bestgain)
{
 int* perm[4];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     perm[2] = first_permutation(rangelist[2]);
     do{
       perm[3] = first_permutation(rangelist[3]);
       do{
         update_best_discrete_condition(split, perm, rangelist, iter, featurecounts, partitioncounts, bestgain);
       }while (next_permutation(perm[3], rangelist[3]));
       safe_free(perm[3]);
     }while (next_permutation(perm[2], rangelist[2]));
     safe_free(perm[2]);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rsi, 0x10(%rsp)
movl (%rsi), %edi
callq 0x3873a
leaq 0x60(%rsp), %r14
movq %rax, 0x18(%rsp)
movq %rax, (%r14)
movq 0x50(%rsp), %r15
movq 0x48(%rsp), %rbx
movq 0x40(%rsp), %r13
movq 0x38(%rsp), %r12
movq 0x10(%rsp), %rbp
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x3873a
movq %rax, 0x20(%rsp)
movq %rax, 0x68(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x3873a
movq %rax, 0x28(%rsp)
movq %rax, 0x70(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x3873a
movq %rax, 0x30(%rsp)
movq %rax, 0x78(%rsp)
movq %r13, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq 0x58(%rsp), %r9
callq 0x314e3
movl 0xc(%rbp), %esi
movq 0x30(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x31988
movq 0x30(%rsp), %rdi
callq 0x39194
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x28(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x31971
movq 0x28(%rsp), %rdi
callq 0x39194
movq 0x10(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x20(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x3195a
movq 0x20(%rsp), %rdi
callq 0x39194
movq 0x10(%rsp), %rax
movl (%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x31943
movq 0x18(%rsp), %rdi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/krule.c
// Function: find_best_discrete_condition_omnivariate
Decisionconditionptr find_best_discrete_condition_omnivariate(Instanceptr growset, int positive)
{
 double bestgain = 0.0, gain;
 Decisionconditionptr* conditions;
 Decisionconditionptr result;
 int bestdepth = -1, depth, modelcount = get_parameter_i("hybridspace");
 conditions = safemalloc(modelcount * sizeof(Decisionconditionptr), "find_best_discrete_condition_omnivariate", 4);
 for (depth = 0; depth < modelcount; depth++)
  {
   conditions[depth] = find_best_discrete_condition(growset, depth + 1, positive, &gain);
   if (gain > bestgain)
    {
     bestgain = gain;
     bestdepth = depth;
    }
  }
 for (depth = 0; depth < modelcount; depth++)
   if (depth != bestdepth)
    {
     free_condition(*(conditions[depth]));
     safe_free(conditions[depth]);
    }
 if (bestdepth != -1)
   result = conditions[bestdepth];
 else
   result = NULL;
 safe_free(conditions);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebp
movq %rdi, %r15
leaq 0x741cb(%rip), %rdi     # 0xa5c20
callq 0x5341c
movl %eax, 0x7c(%rsp)
movslq %eax, %r12
leaq (,%r12,8), %rdi
leaq 0x741bc(%rip), %rsi     # 0xa5c2c
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbx
movl %r12d, %r14d
testl %r12d, %r12d
jle 0x31af0
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movq %r15, 0x80(%rsp)
movl %ebp, %r15d
movsd %xmm0, 0x88(%rsp)
leaq 0x1(%r13), %rbp
movq 0x80(%rsp), %rdi
movl %ebp, %esi
movl %r15d, %edx
leaq 0x90(%rsp), %rcx
callq 0x31b5c
movq %rax, (%rbx,%r13,8)
movsd 0x90(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmoval %r13d, %r12d
maxsd %xmm1, %xmm0
movq %rbp, %r13
cmpq %rbp, %r14
jne 0x31a9d
jmp 0x31af6
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x0, 0x7c(%rsp)
jle 0x31b2d
movl %r12d, %r15d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x31b25
movq (%rbx,%r13,8), %rsi
movl $0xe, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x7a935
movq (%rbx,%r13,8), %rdi
callq 0x39194
incq %r13
cmpq %r13, %r14
jne 0x31b03
cmpl $-0x1, %r12d
je 0x31b3c
movslq %r12d, %rax
movq (%rbx,%rax,8), %r14
jmp 0x31b3f
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x39194
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/ktree.c
// Function: copy_of_korderingsplit
Korderingsplit copy_of_korderingsplit(Korderingsplit ksplit)
{
	int i, size;
	Korderingsplit newsplit;
	newsplit.featurecount = ksplit.featurecount;
	newsplit.discretesplit = safemalloc(newsplit.featurecount * sizeof(int), "copy_of_korderingsplit", 4);
	newsplit.featurelist = safemalloc(newsplit.featurecount * sizeof(int), "copy_of_korderingsplit", 5);
	newsplit.sortorder = safemalloc(newsplit.featurecount * sizeof(int*), "copy_of_korderingsplit", 6);
	memcpy(newsplit.discretesplit, ksplit.discretesplit, newsplit.featurecount * sizeof(int));
	memcpy(newsplit.featurelist, ksplit.featurelist, newsplit.featurecount * sizeof(int));
	for (i = 0; i < newsplit.featurecount; i++)
  {
   size = current_dataset->features[newsplit.featurelist[i]].valuecount;
   newsplit.sortorder[i] = safemalloc(size * sizeof(int), "copy_of_korderingsplit", 12);
   memcpy(newsplit.sortorder[i], ksplit.sortorder[i], size * sizeof(int));
  }
	return newsplit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x40(%rsp), %rbp
movl %ebp, (%rdi)
leaq (,%rbp,4), %r12
leaq 0x73df8(%rip), %r15     # 0xa5c68
movq %r12, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r13
movq %rax, 0x10(%rbx)
movq %r12, %rdi
movq %r15, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, %r14
movq %rax, 0x8(%rbx)
leaq (,%rbp,8), %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, %r15
movq %rbx, (%rsp)
movq %rax, 0x18(%rbx)
movq 0x50(%rsp), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x4310
movq 0x48(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x4310
testq %rbp, %rbp
jle 0x31f3f
leaq 0x40(%rsp), %rax
movq 0x18(%rax), %rbx
xorl %r12d, %r12d
leaq 0xa097a(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq (%r14,%r12,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %r13
shlq $0x2, %r13
movq %r13, %rdi
leaq 0x73d4e(%rip), %rsi     # 0xa5c68
movl $0xc, %edx
callq 0x390f5
movq %rax, (%r15,%r12,8)
movq (%rbx,%r12,8), %rsi
movq %rax, %rdi
movq %r13, %rdx
callq 0x4310
incq %r12
cmpq %r12, %rbp
jne 0x31eef
movq (%rsp), %rax
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/ktree.c
// Function: create_kordering_condition
Decisioncondition create_kordering_condition(Korderingsplit ksplit, char comparison)
{
 Decisioncondition rule;
 rule.featureindex = DISCRETEMIX;
 rule.ksplit = copy_of_korderingsplit(ksplit);
	rule.comparison = comparison;
 return rule;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0xfffffffb, (%rdi)     # imm = 0xFFFFFFFB
addq $0x50, %rdi
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x31e4c
movb %bl, 0x4(%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/ktree.c
// Function: find_best_discrete_split_1
void find_best_discrete_split_1(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, double* bestgain)
{
 int* perm[1];
 perm[0] = first_permutation(rangelist[0]);
 do{
   update_best_discrete_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, bestgain);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl (%rsi), %edi
callq 0x3873a
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq %rbx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x3200b
movl (%r13), %esi
movq %rbx, %rdi
callq 0x38c67
testl %eax, %eax
jne 0x31fc3
movq %rbx, %rdi
addq $0x18, %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/ktree.c
// Function: find_best_discrete_split_2
void find_best_discrete_split_2(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, double* bestgain)
{
 int* perm[2];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     update_best_discrete_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, bestgain);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
movl (%rsi), %edi
callq 0x3873a
leaq 0x40(%rsp), %rcx
movq %rax, 0x8(%rsp)
movq %rax, (%rcx)
movq 0x38(%rsp), %r14
movq 0x30(%rsp), %r15
movq 0x28(%rsp), %r12
movq 0x20(%rsp), %rbp
movq 0x18(%rsp), %rbx
movl 0x4(%r13), %edi
callq 0x3873a
movq %rax, 0x10(%rsp)
movq %rax, 0x48(%rsp)
movq %r14, (%rsp)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x3200b
movl 0x4(%r13), %esi
movq 0x10(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x3224b
movq 0x10(%rsp), %rdi
callq 0x39194
movl (%r13), %esi
movq 0x8(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x32238
movq 0x8(%rsp), %rdi
addq $0x58, %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/ktree.c
// Function: find_best_discrete_split_3
void find_best_discrete_split_3(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, double* bestgain)
{
 int* perm[3];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     perm[2] = first_permutation(rangelist[2]);
     do{
       update_best_discrete_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, bestgain);
     }while (next_permutation(perm[2], rangelist[2]));
     safe_free(perm[2]);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x8(%rsp)
movl (%rsi), %edi
callq 0x3873a
leaq 0x50(%rsp), %r14
movq %rax, 0x10(%rsp)
movq %rax, (%r14)
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %rbp
movq 0x28(%rsp), %r13
movq 0x8(%rsp), %rbx
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x3873a
movq %rax, 0x18(%rsp)
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x3873a
movq %rax, 0x20(%rsp)
movq %rax, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x3200b
movl 0x8(%rbx), %esi
movq 0x20(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x32335
movq 0x20(%rsp), %rdi
callq 0x39194
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x3231e
movq 0x18(%rsp), %rdi
callq 0x39194
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x10(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x32307
movq 0x10(%rsp), %rdi
addq $0x68, %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/ktree.c
// Function: find_best_discrete_split_4
void find_best_discrete_split_4(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, double* bestgain)
{
 int* perm[4];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     perm[2] = first_permutation(rangelist[2]);
     do{
       perm[3] = first_permutation(rangelist[3]);
       do{
         update_best_discrete_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, bestgain);
       }while (next_permutation(perm[3], rangelist[3]));
       safe_free(perm[3]);
     }while (next_permutation(perm[2], rangelist[2]));
     safe_free(perm[2]);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x10(%rsp)
movl (%rsi), %edi
callq 0x3873a
leaq 0x60(%rsp), %r14
movq %rax, 0x18(%rsp)
movq %rax, (%r14)
movq 0x50(%rsp), %r15
movq 0x48(%rsp), %r12
movq 0x40(%rsp), %rbp
movq 0x38(%rsp), %r13
movq 0x10(%rsp), %rbx
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x3873a
movq %rax, 0x20(%rsp)
movq %rax, 0x68(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x3873a
movq %rax, 0x28(%rsp)
movq %rax, 0x70(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x3873a
movq %rax, 0x30(%rsp)
movq %rax, 0x78(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x3200b
movl 0xc(%rbx), %esi
movq 0x30(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x32462
movq 0x30(%rsp), %rdi
callq 0x39194
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x28(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x3244b
movq 0x28(%rsp), %rdi
callq 0x39194
movq 0x10(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x20(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x32434
movq 0x20(%rsp), %rdi
callq 0x39194
movq 0x10(%rsp), %rax
movl (%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x3241d
movq 0x18(%rsp), %rdi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/ktree.c
// Function: create_ktreechildren
int create_ktreechildren(Decisionnodeptr node, C45_parameterptr p)
{
 int i, bestdepth;
 double gain, bestgain = +INT_MAX;
 Korderingsplit ksplit, bestksplit;
 node->conditiontype = UNIVARIATE_CONDITION;
 if (!(can_be_divided(node, p)))
   return 1;
 node->featureno = DISCRETEMIX;
 node->ksplit.featurecount = get_parameter_i("smallsetsize");
 if (node->ksplit.featurecount == 0)
  {
   for (i = 1; i <= get_parameter_i("hybridspace"); i++)
    {
     ksplit = find_best_discrete_split(node, i, &gain);
     if (gain < bestgain)
      {
       bestgain = gain;
       bestdepth = i;
       bestksplit = ksplit;
      }
    }
   node->ksplit = bestksplit;
  }
 else
   node->ksplit = find_best_discrete_split(node, node->ksplit.featurecount, &gain);
 if (node->ksplit.featurecount == 0)
  {
   safe_free(node->ksplit.sortorder);
   safe_free(node->ksplit.featurelist);
   safe_free(node->ksplit.discretesplit);
   node->featureno = LEAF_NODE;
   return 1;
  }
 if (!(make_children_discrete(node)))
   return 1;
 create_ktreechildren(node->left, p);
 create_ktreechildren(node->right, p);
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl $0x0, 0x98(%rdi)
callq 0x1c8e2
testl %eax, %eax
je 0x32b96
movl $0xfffffffb, 0x30(%rbx) # imm = 0xFFFFFFFB
leaq 0x6fe12(%rip), %rdi     # 0xa2874
callq 0x5341c
leaq 0x140(%rbx), %r14
movl %eax, 0x140(%rbx)
testl %eax, %eax
je 0x32aa6
leaq 0x48(%rsp), %r15
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x32515
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
jmp 0x32b40
movq %r12, 0x18(%rsp)
leaq 0x7316e(%rip), %rdi     # 0xa5c20
callq 0x5341c
testl %eax, %eax
jle 0x32b28
movsd 0x6fa55(%rip), %xmm0    # 0xa2518
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x48(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x73144(%rip), %r13     # 0xa5c20
incl %ebp
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x32515
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x32b1c
movupd 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movaps %xmm2, 0x30(%rsp)
movapd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
callq 0x5341c
cmpl %eax, %ebp
jl 0x32adc
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq 0x18(%rsp), %r12
cmpl $0x0, (%r14)
je 0x32b6b
movq %rbx, %rdi
callq 0x327f1
testl %eax, %eax
je 0x32b96
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x32a29
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x32a29
jmp 0x32b96
movq 0x158(%rbx), %rdi
callq 0x39194
movq 0x148(%rbx), %rdi
callq 0x39194
movq 0x150(%rbx), %rdi
callq 0x39194
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: goto_endconstructor
void goto_endconstructor(int* variable, char* constructorname, char* endconstructorname, char** code, int linecount, int* instruction_pointer)
{
 /*!Last Changed 14.07.2006*/
 char templine[READLINELENGTH], *p;
 int howmany = 1, i;
 *variable = 0;
 for (i = *instruction_pointer + 1; i < linecount; i++)
  {
   strcpy(templine, code[i]);
   p = strtok(templine," \t\n");
   if (strcmp(p, constructorname) == 0)
     howmany++;
   else
     if (strcmp(p, endconstructorname) == 0)
      {
       howmany--;
       if (howmany == 0)
         break;
      }
  }
 *instruction_pointer = i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, (%rdi)
movslq (%r9), %rax
leal 0x1(%rax), %ebp
cmpl %r8d, %ebp
jge 0x32c4f
movl %r8d, %r13d
movq %r9, 0x8(%rsp)
leaq (%rcx,%rax,8), %r14
addq $0x8, %r14
movl $0x1, %r15d
leaq 0x20(%rsp), %r12
movq (%r14), %rsi
movq %r12, %rdi
callq 0x4270
movq %r12, %rdi
leaq 0x73561(%rip), %rsi     # 0xa6169
callq 0x4280
movq %rax, %rbx
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x4260
testl %eax, %eax
je 0x32c39
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x4260
testl %eax, %eax
jne 0x32c3c
decl %r15d
jne 0x32c3c
jmp 0x32c4a
incl %r15d
incl %ebp
addq $0x8, %r14
cmpl %ebp, %r13d
jne 0x32bf3
movl %r13d, %ebp
movq 0x8(%rsp), %r9
movl %ebp, (%r9)
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: set_variable
int set_variable(char* name, void* value)
{
 /*!Last Changed 22.12.2006 added matrix type*/
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 05.11.2003 Added File variable with type 4*/
 /*!Last Changed 02.05.2002*/
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
  {
   printf(m1437, name);
   return 0;
  }
 switch (myvar->type)
  {
   case INTEGER_TYPE:myvar->value.intvalue = atoi((char *)value);
                     break;
   case REAL_TYPE   :myvar->value.floatvalue = atof((char *)value);
                     break;
   case ARRAY_TYPE  :set_multidimensional_array(myvar, value);
                     break;
   case STRING_TYPE :
			case FILE_TYPE   :if (myvar->value.stringvalue)
                       safe_free(myvar->value.stringvalue);
                     myvar->value.stringvalue = strcopy(myvar->value.stringvalue, (char *)value);
                     break;
   case MATRIX_TYPE :if (myvar->value.matrixvalue)
																					 {
																						 matrix_free(*(myvar->value.matrixvalue));
																						 safe_free(myvar->value.matrixvalue);
                       myvar->value.matrixvalue = NULL;
																					 }
                     if (strcmp((char *)value, "0") != 0)
  				                 myvar->value.matrixvalue = (matrixptr)value;
                     break;
   default          :break;
  }
 return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x3440c
testq %rax, %rax
je 0x32e9f
movq %rax, %r14
movl (%rax), %eax
movl $0x1, %ebx
cmpq $0x5, %rax
ja 0x32eb2
leaq 0x72e26(%rip), %rcx     # 0xa5c9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x32e8d
callq 0x39194
movq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x3a404
movq %rax, 0x28(%r14)
jmp 0x32eb2
leaq 0x7379f(%rip), %rdi     # 0xa6645
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x4030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x4200
movl %eax, 0x28(%r14)
jmp 0x32eb2
movq %r15, %rdi
callq 0x4130
movsd %xmm0, 0x28(%r14)
jmp 0x32eb2
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x32f04
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x3dbad
movq 0x28(%r14), %rdi
callq 0x39194
movq $0x0, 0x28(%r14)
leaq 0x7029e(%rip), %rsi     # 0xa31a9
movq %r15, %rdi
callq 0x4260
testl %eax, %eax
je 0x32eb2
movq %r15, 0x28(%r14)
jmp 0x32eb2
movq %r14, %rdi
movq %r15, %rsi
callq 0x34f93
jmp 0x32eb2
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: check_parameter_type
int check_parameter_type(char* varname, VARIABLE_TYPE vartype, variableptr variables, int variablecount)
{
 /*!Last Changed 21.12.2006*/
 int k;
 Variable myvar;
 k = return_variable_index(varname, variables, variablecount);
 if (k == -1)
   return FAILURE;
 else
  {
   myvar = variables[k];
   while (myvar.type == ARRAY_TYPE) 
     myvar = myvar.value.array[0];
   if (myvar.type != vartype)
     return FAILURE;
  }
 return SUCCESS; 
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdx, %rsi
movl %ecx, %edx
callq 0x32f77
cmpl $-0x1, %eax
je 0x32f6d
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl (%r14,%rax), %ecx
cmpl $0x3, %ecx
jne 0x32f64
addq %rax, %r14
movq 0x28(%r14), %r14
movl (%r14), %ecx
cmpl $0x3, %ecx
je 0x32f58
xorl %eax, %eax
cmpl %ebx, %ecx
sete %al
jmp 0x32f6f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: return_variable_index
int return_variable_index(char* name, variableptr vars, int varcount)
{
 /*!Last Changed 02.05.2002*/
 int i;
 char* st = array_variable(name);
 if (st)
  {
   for (i = 0; i < varcount; i++)
     if (strcmp(st, vars[i].name) == 0)
      {
       safe_free(st);
       return i;
      }
  }
 else
  {
   for (i = 0; i < varcount; i++)
     if (strcmp(name, vars[i].name)==0)
       return i;
  }
	if (st)
		 safe_free(st);
 return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
callq 0x3468b
movq %rax, %rbx
testq %rax, %rax
je 0x32fc2
testl %ebp, %ebp
jle 0x32feb
movl %ebp, %r12d
addq $0x18, %r14
xorl %r15d, %r15d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4260
testl %eax, %eax
je 0x32ff6
incq %r15
addq $0x30, %r14
cmpq %r15, %r12
jne 0x32fa5
jmp 0x32feb
testl %ebp, %ebp
jle 0x32feb
movl %ebp, %r13d
addq $0x18, %r14
xorl %r15d, %r15d
movq (%r14), %rsi
movq %r12, %rdi
callq 0x4260
testl %eax, %eax
je 0x32ffe
incq %r15
addq $0x30, %r14
cmpq %r15, %r13
jne 0x32fd0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x32ffe
movq %rbx, %rdi
callq 0x39194
movl %r15d, %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/lang.c
// Function: add_default_variables
void add_default_variables(variableptr* variables, int* variablecount)
{
	/*!Last Changed 06.08.2007*/
 add_variable(REAL_TYPE, default_variables, DEFAULT_VARIABLE_COUNT, variables, variablecount);
 add_variable(STRING_TYPE, default_string_variables, DEFAULT_STRING_VARIABLE_COUNT, variables, variablecount);
 add_variable(STRING_TYPE, default_array_variables, DEFAULT_ARRAY_VARIABLE_COUNT, variables, variablecount);
 add_variable(STRING_TYPE, default_performance_variables, DEFAULT_PERFORMANCE_VARIABLE_COUNT, variables, variablecount);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9eac6(%rip), %rsi     # 0xd1de0
movl $0x1, %edi
movl $0xa, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x3338a
leaq 0x9eafa(%rip), %rsi     # 0xd1e30
movl $0x2, %edi
movl $0xa, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x3338a
leaq 0x9eb2e(%rip), %rsi     # 0xd1e80
movl $0x2, %edi
movl $0x1e, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x3338a
leaq 0x9ec02(%rip), %rsi     # 0xd1f70
movl $0x2, %edi
movl $0x2, %edx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3338a
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: check_of_variables
int check_of_variables(char* st, variableptr variables, int variablecount)
{
	/*!Last Changed 12.10.2004*/
	int i = 0, len = strlen(st), mode = 0, start, end, j;
	char varname[READLINELENGTH];
	while (i < len)
	 {
		 if (st[i] == '%')
			 {
				 mode = (mode + 1) % 2;
					if (mode == 1)
						 start = i + 1;
					else
					 {
						 end = i - 1;
							if (start < end)
							 {
								 for (j = start; j <= end; j++)
										 varname[j - start] = st[j];
									varname[j - start] = '\0';
         if (return_variable_index(varname, variables, variablecount) == -1)
										 return 0;
							 }
					 }
			 }
		 i++;
	 }
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movl %edx, 0x4(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
callq 0x4190
movq %rax, %r12
testl %r12d, %r12d
jle 0x33e56
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
xorl %r13d, %r13d
xorl %eax, %eax
cmpb $0x25, (%r15,%r13)
jne 0x33e4b
testb $0x1, %al
jne 0x33df2
leal 0x1(%r13), %ebx
movl $0x1, %eax
jmp 0x33e4b
leaq -0x1(%r13), %rcx
movslq %ebx, %r14
xorl %eax, %eax
cmpq %r14, %rcx
jle 0x33e4b
leaq (%r15,%r14), %rsi
movl %r14d, %edx
notl %edx
addl %r13d, %edx
incq %rdx
leaq 0x10(%rsp), %rdi
callq 0x4310
addq %rbp, %r14
xorl %eax, %eax
decq %rax
cmpq %rax, %r14
jne 0x33e1e
negl %eax
cltq
movb $0x0, 0x10(%rsp,%rax)
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x32f77
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x33e5b
incq %r13
decq %rbp
cmpq %r12, %r13
jne 0x33ddc
movl $0x1, %eax
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: free_variables
void free_variables(variableptr vars, int count)
{
 /*!Last Changed 22.12.2006 added matrix type*/
 /*!Last Changed 04.01.2006 added free_multidimensional_array*/
	/*!Last Changed 29.11.2004*/
	int i;
 for (i = 0; i < count; i++)
	 {
		 safe_free(vars[i].name);
			switch (vars[i].type)
			 {
			  case INTEGER_TYPE:
					case REAL_TYPE   :break;
					case STRING_TYPE :
					case FILE_TYPE   :if (vars[i].value.stringvalue)
													            safe_free(vars[i].value.stringvalue);
						                 break;
     case MATRIX_TYPE :if (vars[i].value.matrixvalue)
                        {
                         matrix_free(*(vars[i].value.matrixvalue));
                         safe_free(vars[i].value.matrixvalue);
                        }
                       break;
					case ARRAY_TYPE  :free_multidimensional_array(&(vars[i]));
												           break;
     default          :break;
			 }
	 }
}

// Assembly:
testl %esi, %esi
jle 0x33ee0
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %r14d
leaq 0x71ef9(%rip), %r15     # 0xa5d7c
movq 0x18(%rbx), %rdi
callq 0x39194
movl (%rbx), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x33ed2
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
jne 0x33ecd
jmp 0x33ed2
movq %rbx, %rdi
callq 0x35055
jmp 0x33ed2
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x33ed2
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x3dbad
movq 0x28(%rbx), %rdi
callq 0x39194
addq $0x30, %rbx
decq %r14
jne 0x33e83
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: charatindex
void charatindex(char* name, int index)
{
	/*!Last Changed 27.01.2004*/
	char* st;
	char message[2];
	st = get_string_value(name);
	if (!st)
		 return;
	sprintf(message, "%c", st[index - 1]);
	set_default_string_variable("sout1", message);
	safe_free(st);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
callq 0x33f20
testq %rax, %rax
je 0x33f19
movq %rax, %rbx
movslq %ebp, %rax
movb -0x1(%rbx,%rax), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
leaq 0x720ab(%rip), %rdi     # 0xa5fb7
callq 0x33f8d
movq %rbx, %rdi
callq 0x39194
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: get_string_value
char* get_string_value(char* name)
{
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 06.02.2004 put controls*/
 /*!Last Changed 27.01.2004*/
	char message[READLINELENGTH], *st = NULL;
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 2, "string");
	if (!myvar)
			return NULL;
	if (myvar->value.stringvalue)
		 strcpy(message, myvar->value.stringvalue);
	else
		{
			printf(m1295, name);
			return NULL;
		}
	st = strcopy(st, message);
	return st;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdi, %rbx
leaq 0x736d6(%rip), %rdx     # 0xa760a
movl $0x2, %esi
callq 0x341e0
testq %rax, %rax
je 0x33f66
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0x33f6b
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4270
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3a404
movq %rax, %r14
jmp 0x33f7f
xorl %r14d, %r14d
jmp 0x33f7f
leaq 0x7260a(%rip), %rdi     # 0xa657c
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4030
movq %r14, %rax
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: set_default_string_variable
int set_default_string_variable(char* name, char* st)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 05.05.2002*/
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
   return 0;
 if (myvar->value.stringvalue)
   safe_free(myvar->value.stringvalue);
 myvar->value.stringvalue = strcopy(myvar->value.stringvalue, st);
 return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x3440c
testq %rax, %rax
je 0x33fc6
movq %rax, %r14
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x33faf
callq 0x39194
movq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x3a404
movq %rax, 0x28(%r14)
movl $0x1, %eax
jmp 0x33fc8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: stringlength
void stringlength(char* name)
{
	/*!Last Changed 27.01.2004*/
	char* st;
	st = get_string_value(name);
	if (!st)
		 return;
	set_default_variable("out1", strlen(st) + 0.0);
	safe_free(st);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x33f20
testq %rax, %rax
je 0x34032
movq %rax, %rbx
movq %rax, %rdi
callq 0x4190
movq %rax, %r14
leaq 0x71fc5(%rip), %rdi     # 0xa5fb8
callq 0x3440c
testq %rax, %rax
je 0x34023
movq %r14, %xmm0
punpckldq 0x71ec6(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x71ece(%rip), %xmm0    # 0xa5ee0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39194
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: countchar
void countchar(char* name, char* ch)
{
 /*!Last Changed 27.01.2004*/
	int count = 0, i, len;
	char* st;
	st = get_string_value(name);
	if (!st)
		 return;
	len = strlen(st);
	for (i = 0; i < len; i++)
		 if (st[i] == ch[0])
				 count++;
	set_default_variable("out1", count + 0.0);
	safe_free(st);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x33f20
testq %rax, %rax
je 0x340a4
movq %rax, %rbx
movq %rax, %rdi
callq 0x4190
testl %eax, %eax
jle 0x340ac
movb (%r14), %cl
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
cmpb %cl, (%rbx,%rdx)
sete %dil
addl %edi, %esi
incq %rdx
cmpq %rdx, %rax
jne 0x3408b
cvtsi2sd %esi, %xmm0
jmp 0x340b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x71efc(%rip), %rdi     # 0xa5fb8
callq 0x3440c
testq %rax, %rax
je 0x340d0
movsd (%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: tokenize
void tokenize(char* name, char* separators)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 27.01.2004*/
 int i, count;
	char message[READLINELENGTH];
 char* tokens[1000];
	char varname[15];
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 2, "string");
	if (!myvar)
			return;
 if (myvar->value.stringvalue)
  	strcpy(message, myvar->value.stringvalue);
	else
		{
			printf(m1295, name);
			return;
		}
 stringlist(message, separators, tokens, &count);
 for (i = 0; i < count; i++)
  {
   sprintf(varname,"aout1[%d]", i + 1);
   set_variable(varname, tokens[i]);
   safe_free(tokens[i]);
  }
	set_default_variable("out1", count + 0.0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7c080, %rsp          # imm = 0x7C080
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7350e(%rip), %rdx     # 0xa760a
movl $0x2, %esi
callq 0x341e0
testq %rax, %rax
je 0x341ae
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0x341bf
leaq 0x1f60(%rsp), %r14
movq %r14, %rdi
callq 0x4270
leaq 0x20(%rsp), %rdx
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x3a431
movl (%r15), %r12d
testl %r12d, %r12d
jle 0x34193
leaq 0x72450(%rip), %rbx     # 0xa65a3
leaq 0x11(%rsp), %r14
xorl %r13d, %r13d
leaq 0x1(%r13), %r15
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x41b0
movq 0x20(%rsp,%r13,8), %rsi
movq %r14, %rdi
callq 0x32e47
movq 0x20(%rsp,%r13,8), %rdi
callq 0x39194
movslq 0xc(%rsp), %r12
movq %r15, %r13
cmpq %r12, %r15
jl 0x3415b
leaq 0x71e1e(%rip), %rdi     # 0xa5fb8
callq 0x3440c
testq %rax, %rax
je 0x341ae
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x28(%rax)
addq $0x7c080, %rsp          # imm = 0x7C080
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x723b6(%rip), %rdi     # 0xa657c
movq %r14, %rsi
xorl %eax, %eax
addq $0x7c080, %rsp          # imm = 0x7C080
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: get_and_check_variable_type
variableptr get_and_check_variable_type(char* name, VARIABLE_TYPE validtype, char* message)
{
 /*!Last Changed 03.01.2006*/
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
   printf(m1302, name);
 else
   if (myvar->type != validtype)
    {
     printf(m1303, message);
     return NULL;
    }
 return myvar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x3440c
movq %rax, %rbx
testq %rax, %rax
je 0x3420e
cmpl %ebp, (%rbx)
je 0x3421f
leaq 0x7247d(%rip), %rdi     # 0xa6684
xorl %ebx, %ebx
movq %r14, %rsi
jmp 0x34218
leaq 0x72453(%rip), %rdi     # 0xa6668
movq %r15, %rsi
xorl %eax, %eax
callq 0x4030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: read_userfile
void read_userfile(char* name, char* varname)
{
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 29.10.2005*/
 /*!Last Changed 21.10.2004*/
 /*!Last Changed 27.01.2004*/
	char message[READLINELENGTH];
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (myvar->userfile)
		 fscanf(myvar->userfile, "%s", message);
	set_variable(varname, message);
}

// Assembly:
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq %rsi, %rbx
leaq 0x6ea9d(%rip), %rdx     # 0xa2cdc
movl $0x4, %esi
callq 0x341e0
testq %rax, %rax
je 0x34273
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x34268
leaq 0x70c9a(%rip), %rsi     # 0xa4ef8
movq %rsp, %rdx
xorl %eax, %eax
callq 0x4070
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x32e47
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: get_variable
variableptr get_variable(char* st)
{
	/*!Last Changed 02.01.2006*/
	int ind;
	char* st2;
 variableptr myvar;
 ind = return_variable_index(st, vars, varcount);
 if (ind != -1)
		{
   st2 = array_variable(st);
   if (st2)
				{
     myvar = array_pos(st, &(vars[ind]));
     safe_free(st2);
					return myvar;
			 }
   else
				 return &(vars[ind]);
	 }
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9e44b(%rip), %r15     # 0xd2868
movq (%r15), %rsi
leaq 0x9e0dd(%rip), %rax     # 0xd2504
movl (%rax), %edx
callq 0x32f77
cmpl $-0x1, %eax
je 0x3446e
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3468b
movq %rax, %r14
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq (%r15), %rax
testq %r14, %r14
je 0x34470
movq %rbx, %rdi
movq %rax, %rsi
callq 0x34b4f
movq %rax, %rbx
movq %r14, %rdi
callq 0x39194
movq %rbx, %rax
jmp 0x34470
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: write_userfile
void write_userfile(char* name, char* line)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 05.11.2003*/
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (myvar->userfile)
			fprintf(myvar->userfile, "%s\n", line);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x6e856(%rip), %rdx     # 0xa2cdc
movl $0x4, %esi
callq 0x341e0
testq %rax, %rax
je 0x344b0
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x344b0
leaq 0x79121(%rip), %rsi     # 0xad5c6
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x42e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: open_userfile
void open_userfile(char* name, char* filetype)
{
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 27.01.2004*/
 /*!Last Changed 10.11.2003*/
 variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (!(myvar->userfile))
		{
			myvar->userfile = fopen(myvar->value.stringvalue, filetype);
			if (!(myvar->userfile))
					printf(m1296, myvar->value.stringvalue, filetype);
		}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x6e81c(%rip), %rdx     # 0xa2cdc
movl $0x4, %esi
callq 0x341e0
testq %rax, %rax
je 0x344ee
movq %rax, %r14
cmpq $0x0, 0x10(%rax)
jne 0x344ee
movq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x40f0
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x344f6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x28(%r14), %rsi
leaq 0x720ac(%rip), %rdi     # 0xa65ad
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: close_userfile
void close_userfile(char* name)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 05.11.2003*/
 variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (myvar->userfile)
		{
			fclose(myvar->userfile);
			myvar->userfile = NULL;
		}
}

// Assembly:
pushq %rbx
leaq 0x6e7c2(%rip), %rdx     # 0xa2cdc
movl $0x4, %esi
callq 0x341e0
testq %rax, %rax
je 0x34542
movq %rax, %rbx
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x34542
callq 0x42a0
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: array_variable
char* array_variable(char* name)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 02.05.2002*/
 char* st = NULL;
 int i, len;
	len = strlen(name);
 for (i = 0; i < len; i++)
   if (name[i] == '[')
    {
     st = safemalloc(sizeof(char) * (i + 1), "array_variable", 7);
     strncpy(st, name, i);
     st[i] = '\0';
     break;
    }
 return st;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4190
testl %eax, %eax
jle 0x346b8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpb $0x5b, (%rbx,%r15)
je 0x346bd
incq %r15
cmpq %r15, %rax
jne 0x346a7
jmp 0x346e8
xorl %r14d, %r14d
jmp 0x346e8
leal 0x1(%r15), %edi
leaq 0x71f41(%rip), %rsi     # 0xa6609
movl $0x7, %edx
callq 0x390f5
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x42b0
movb $0x0, (%r14,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: check_var
BOOLEAN check_var(struct variable var, char* value)
{
	/*!Last Changed 05.11.2003 Added file variable with type 4*/
 /*!Last Changed 02.05.2002*/
 int tmp;
 double tmpd;
 switch (var.type)
  {
   case INTEGER_TYPE:tmp = atoi(value);
                     if (var.value.intvalue == tmp)
                       return BOOLEAN_TRUE;
                     else
                       return BOOLEAN_FALSE;
   case REAL_TYPE   :tmpd = atof(value);
                     if (var.value.floatvalue == tmpd)
                       return BOOLEAN_TRUE;
                     else
                       return BOOLEAN_FALSE;
   case STRING_TYPE :
			case FILE_TYPE   :if (strcmp(var.value.stringvalue, value) == 0)
                       return BOOLEAN_TRUE;
                     else
                       return BOOLEAN_FALSE;
   default          :break;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbx
movl 0x10(%rsp), %ecx
xorl %eax, %eax
cmpq $0x4, %rcx
ja 0x34749
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0x716af(%rip), %rdx     # 0xa5dbc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x28(%rbx), %rdi
callq 0x4260
testl %eax, %eax
jmp 0x34746
movq %rsi, %rdi
callq 0x4130
cmpeqsd 0x28(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x34749
movq %rsi, %rdi
callq 0x4200
cmpl %eax, 0x28(%rbx)
sete %al
movzbl %al, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: get_value
double get_value(struct variable var)
{
/*!Last Changed 02.05.2002*/
 switch (var.type)
  {
   case INTEGER_TYPE:return var.value.intvalue;
   case REAL_TYPE   :return var.value.floatvalue;
   default          :return 0;
  }
 return 0;
}

// Assembly:
leaq 0x8(%rsp), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x347a6
xorps %xmm0, %xmm0
testl %ecx, %ecx
jne 0x347ab
xorps %xmm0, %xmm0
cvtsi2sdl 0x28(%rax), %xmm0
retq
movsd 0x28(%rax), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/lang.c
// Function: array_sizes
int* array_sizes(char* name, int* dimcount)
{
 /*!Last Changed 06.01.2006*/
 int i, start, end = 0, len, *dimensions = NULL;
 char st[READLINELENGTH], *p;
 len = strlen(name);
 for (i = 0; i < len; i++)
   if (name[i] == '[')
     start = i + 1;
   else
     if (name[i] == ']')
      {
       end = i - 1;
       break;
      }
 for (i = start; i <= end; i++)
   st[i - start] = name[i];
 st[i - start] = '\0';
 p = strtok(st, ",");
 *dimcount = 0;
 while (p)
  {
   (*dimcount)++;
   dimensions = alloc(dimensions, (*dimcount) * sizeof(int), *dimcount);
   dimensions[(*dimcount) - 1] = atoi(p);
   p = strtok(NULL, ",");
  }
 return dimensions;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4190
testl %eax, %eax
jle 0x34a9f
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movzbl (%r14,%r15), %ecx
cmpl $0x5b, %ecx
je 0x34a8e
cmpl $0x5d, %ecx
jne 0x34a92
jmp 0x34aa4
leal 0x1(%r15), %ebp
incq %r15
cmpq %r15, %rax
jne 0x34a7d
xorl %r15d, %r15d
jmp 0x34aa7
xorl %r15d, %r15d
jmp 0x34aa7
decl %r15d
movl %r15d, %edx
movl %ebp, %eax
subl %ebp, %edx
jl 0x34aca
movslq %ebp, %rax
addq %rax, %r14
incq %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4310
incl %r15d
movl %r15d, %eax
subl %ebp, %eax
cltq
movb $0x0, (%rsp,%rax)
leaq 0x70f95(%rip), %rsi     # 0xa5a6e
movq %rsp, %rdi
callq 0x4280
movl $0x0, (%rbx)
testq %rax, %rax
je 0x34b39
movq %rax, %r12
xorl %r14d, %r14d
leaq 0x70f75(%rip), %r15     # 0xa5a6e
movslq (%rbx), %rax
leaq 0x1(%rax), %rdx
movl %edx, (%rbx)
leaq 0x4(,%rax,4), %rsi
movq %r14, %rdi
callq 0x390c8
movq %rax, %r14
movq %r12, %rdi
callq 0x4200
movslq (%rbx), %rcx
movl %eax, -0x4(%r14,%rcx,4)
xorl %edi, %edi
movq %r15, %rsi
callq 0x4280
movq %rax, %r12
testq %rax, %rax
jne 0x34af9
jmp 0x34b3c
xorl %r14d, %r14d
movq %r14, %rax
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq