LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariaterule.c
// Function: error_of_ruleset_with_deleted_rules
int error_of_ruleset_with_deleted_rules(Ruleset set, Instanceptr data, int* deleted)
{
/*!Last Changed 14.01.2004*/
 int instanceclassno, covered, error, i;
 Instanceptr test = data;
 Decisionruleptr tmp;
 error = 0;
 while (test)
  {
   instanceclassno = give_classno(test);
   covered = 0;
   tmp = set.start;
   i = 0;
   while (tmp)
    {
     if ((!deleted[i]) && rule_cover_instance(test, *tmp))
      {
       if (instanceclassno != tmp->classno)
         error++;
       covered = 1;
       break;
      }
     i++;
     tmp = tmp->next;
    }
   if (!covered)
     if (instanceclassno != set.defaultclass)
       error++;
   test=test->next;
  }
 return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6c663
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6c635
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x6c61e
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xacfd0
cmpl $0x0, %eax
je 0x6c61e
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x6c615
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0x6c635
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6c5b9
cmpl $0x0, -0x18(%rbp)
jne 0x6c652
movq -0x38(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
je 0x6c650
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c652
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6c587
movl -0x1c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariaterule.c
// Function: validation_error_after_pruning
int validation_error_after_pruning(Ruleset r, Instanceptr cvdata, int positive)
{
 /*!Last Changed 02.02.2004 added safecalloc*/
 /*!Last Changed 14.01.2004*/
 int result, *deleted, rulecount, tmp, i;
 Decisionruleptr rule;
 deleted = safecalloc(r.rulecount, sizeof(int), "validation_error_after_pruning", 3);
 result = error_of_ruleset_with_deleted_rules(r, cvdata, deleted);
 rule = r.start;
 rulecount = 0;
 while (rule && rule->classno != positive)
  {
   rule = rule->next;
   rulecount++;
  }
 for (i = r.rulecount - 1; i >= rulecount; i--)
  {
   deleted[i] = 1;
   tmp = error_of_ruleset_with_deleted_rules(r, cvdata, deleted);
   if (tmp > result)
     deleted[i] = 0;
   else
     result = tmp;
  }
 safe_free(deleted);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x7ab88(%rip), %rdx     # 0xe721f
movl $0x3, %ecx
callq 0x52f40
movq -0x38(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x6c560
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x39(%rbp)
je 0x6c701
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6c70a
jmp 0x6c721
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c6e6
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x6c79e
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rdx
movl $0x1, (%rax,%rdx,4)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x6c560
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x6c78b
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x6c791
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x6c793
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6c72e
movq -0x18(%rbp), %rdi
callq 0x52e80
movl -0x10(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariaterule.c
// Function: count_multivariate_condition_over_threshold
int count_multivariate_condition_over_threshold(Instanceptr list, Decisionconditionptr condition)
{
 /*!Last Changed 09.01.2004*/
 int result = 0;
 Instanceptr tmp = list;
 while (tmp)
  {
   if (multiply_with_matrix(tmp, condition->w) > condition->w0)
     result++;
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6d3fd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x42fb0
movq -0x10(%rbp), %rax
ucomisd 0x30(%rax), %xmm0
jbe 0x6d3ef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6d3bf
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariaterule.c
// Function: find_best_multivariate_condition_svm
Decisionconditionptr find_best_multivariate_condition_svm(Instanceptr* growset, int positive)
{
 /*!Last Changed 18.02.2008*/
 Decisionconditionptr result;
 int i;
 Partition p;
 Svm_split split;
 result = empty_condition();
 result->conditiontype = MULTIVARIATE_CONDITION;
 result->featureindex = LINEAR;
 result->freeparam = current_dataset->multifeaturecount - 1;
 result->comparison = '>';
 result->w = matrix_alloc(1, current_dataset->multifeaturecount - 1);
 p = get_two_class_partition_for_one_vs_all(current_dataset, positive);
	split = find_best_svm_split_for_partition(*growset, p);
	result->w0 = split.rho;
	for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
 		result->w.values[0][i] = split.weights[i];
	free_svm_split(split);
 free_partition(p);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, %al
callq 0xadea0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x18(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
leaq 0x983f7(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x18(%rbp), %rax
movb $0x3e, 0x4(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq 0x983ca(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %esi
subl $0x1, %esi
movl $0x1, %edi
callq 0x57fc0
movq %rax, %rcx
movq -0x178(%rbp), %rax
movq %rcx, -0xd0(%rbp)
movq %rdx, -0xc8(%rbp)
movq -0xd0(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0xc8(%rbp), %rcx
movq %rcx, 0x28(%rax)
leaq 0x9837f(%rip), %rax     # 0x105840
movq (%rax), %rsi
movl -0xc(%rbp), %edx
leaq -0xe8(%rbp), %rdi
callq 0x7a660
movq -0xe8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x170(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xd06a0
leaq -0xc0(%rbp), %rdi
leaq -0x170(%rbp), %rsi
movl $0x88, %edx
callq 0x42b0
movsd -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x982e5(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x6d597
movq -0x48(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6d551
movq %rsp, %rdi
movl $0x11, %ecx
leaq -0xc0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0xc5dd0
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7aa80
movq -0x18(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariaterule.c
// Function: find_best_multivariate_condition
Decisionconditionptr find_best_multivariate_condition(Instanceptr* growset, int positive, MULTIVARIATE_TYPE multivariate_type, Ripper_parameterptr param)
{
 /*!Last Changed 18.02.2008 added linear svm*/
 /*!Last Changed 28.05.2004*/
 switch (param->multivariatealgorithm)
  {
   case  LINEAR_LDA:return find_best_multivariate_condition_lda(growset, positive, multivariate_type, param->variance_explained);
   case  LINEAR_LP :return find_best_multivariate_condition_lp(growset, positive);
   case  LINEAR_SVM:return find_best_multivariate_condition_svm(growset, positive);
   default         :return find_best_multivariate_condition_lda(growset, positive, multivariate_type, param->variance_explained);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x6d8ba
jmp 0x6d8a6
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x6d8d8
jmp 0x6d8b0
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x6d8ea
jmp 0x6d8fc
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rax
movsd 0x50(%rax), %xmm0
callq 0x6d930
movq %rax, -0x8(%rbp)
jmp 0x6d918
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6d5e0
movq %rax, -0x8(%rbp)
jmp 0x6d918
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6d410
movq %rax, -0x8(%rbp)
jmp 0x6d918
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rax
movsd 0x50(%rax), %xmm0
callq 0x6d930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariaterule.c
// Function: multivariate_rule_learner
Ruleset multivariate_rule_learner(Instanceptr* instances, Instanceptr cvdata, Ripper_parameterptr param)
{
 /*!Last Changed 09.01.2004*/
 Ruleset result;
 int classno, *counts, *classes, posclass, classcount, i, maxcount;
 Instanceptr removed, totalremoved = NULL;
 empty_ruleset(&result);
 classno = all_in_one_class(*instances, &maxcount);
 if (!(classno % 10))
   return result;
 counts = find_class_counts(*instances);
 classes = find_max_occured(counts, current_dataset->classno, &classcount);
 safe_free(counts);
 result.defaultclass = classes[0];
 for (i = classcount - 1; i > 0; i--)
  {
   posclass = classes[i];
   removed = learn_multivariate_rules_for_positive_class(instances, &result, posclass, cvdata, param);
   merge_instancelist(&totalremoved, removed);
  }
 safe_free(classes);
 merge_instancelist(instances, totalremoved);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq $0x0, -0x50(%rbp)
callq 0xade30
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x18420
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x6de64
jmp 0x6df0f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x183a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x979c1(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
leaq -0x38(%rbp), %rdx
callq 0x50160
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x60(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x14(%rax)
movl -0x38(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jle 0x6def9
movq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %edx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x6dbe0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x44f40
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6deb1
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x44f40
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: decisiontree_multivariate_linear_node_count
int decisiontree_multivariate_linear_node_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 if (node->featureno == LEAF_NODE)
   return 0;
 else
   if (node->featureno == LINEAR)
     return 1 + decisiontree_multivariate_linear_node_count(node->left) + decisiontree_multivariate_linear_node_count(node->right);
   else
     return decisiontree_multivariate_linear_node_count(node->left) + decisiontree_multivariate_linear_node_count(node->right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x6df3f
movl $0x0, -0x4(%rbp)
jmp 0x6df9a
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x30(%rax)
jne 0x6df74
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6df20
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6df20
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6df9a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6df20
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6df20
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: decisiontree_multivariate_quadratic_node_count
int decisiontree_multivariate_quadratic_node_count(Decisionnodeptr node)
{
 /*!Last Changed 29.01.2005*/
 if (node->featureno == LEAF_NODE)
   return 0;
 else
   if (node->featureno == QUADRATIC)
     return 1 + decisiontree_multivariate_quadratic_node_count(node->left) + decisiontree_multivariate_quadratic_node_count(node->right);
   else
     return decisiontree_multivariate_quadratic_node_count(node->left) + decisiontree_multivariate_quadratic_node_count(node->right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x6dfcf
movl $0x0, -0x4(%rbp)
jmp 0x6e02a
movq -0x10(%rbp), %rax
cmpl $-0x3, 0x30(%rax)
jne 0x6e004
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6dfb0
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6dfb0
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e02a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6dfb0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6dfb0
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: createmultivariatecondition
Decisioncondition createmultivariatecondition(matrix w, double w0, char comparison, int node_type)
{
/*!Last Changed 04.10.2004*/
 Decisioncondition condition;
 condition.w = matrix_copy(w);
 condition.w0 = w0;
 condition.comparison = comparison;
 condition.featureindex = node_type;
 return condition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movb %cl, %al
movq %rdi, -0x38(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movsd %xmm0, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x58550
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x30(%rdi)
movb -0x19(%rbp), %cl
movb %cl, 0x4(%rdi)
movl -0x20(%rbp), %ecx
movl %ecx, (%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: test_multivariate
int test_multivariate(Instanceptr testingdata, matrix w, double w0, int leftclass, int rightclass)
{
 /*!Last Changed 23.09.2004*/
 int i, error = 0;
 double value;
 Instanceptr test = testingdata;
 while (test)
  {
   value = multiply_with_matrix(test, w);
   i = give_classno(test);
   if (value <= w0)
    {
     if (i != leftclass)
       error++;
    }
   else
    {
     if (i != rightclass)
       error++;
    }
   test = test->next;
  }
 return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x6e15c
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x42fb0
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x43530
movl %eax, -0x2c(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x6e13b
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x6e139
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6e14e
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x6e14c
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6e14e
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x6e0ef
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: find_counts_for_multivariate_split
void find_counts_for_multivariate_split(Instanceptr instances, matrix w, double w0, int* leftcounts, int* rightcounts)
{
 /*!Last Changed 22.09.2004*/
 int j;
 double value;
 Instanceptr tmp = instances;
 for (j = 0; j < MAXCLASSES; j++)
  {
   leftcounts[j] = 0;
   rightcounts[j] = 0;
  }
 while (tmp)
  {
   value = multiply_with_matrix(tmp, w);
   j = give_classno(tmp);
   if (value <= w0)
     leftcounts[j]++;
   else
     rightcounts[j]++;
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x32, -0x34(%rbp)
jge 0x6f9bf
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6f990
jmp 0x6f9c1
cmpq $0x0, -0x48(%rbp)
je 0x6fa2c
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x42fb0
movsd %xmm0, -0x40(%rbp)
movq -0x48(%rbp), %rdi
callq 0x43530
movl %eax, -0x34(%rbp)
movsd -0x40(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x6fa0d
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x6fa1e
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x6f9c1
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: find_split_for_partition_multivariate
int find_split_for_partition_multivariate(Instanceptr* instances, Partition p, matrix* w, double*  w0, MULTIVARIATE_TYPE multivariate_type, int* newdim, double variance_explained)
{
 /*!Last Changed 21.09.2004*/
 int result;
 Instanceptr positives = NULL, negatives = NULL;
 divide_instancelist_according_partition(instances, &positives, &negatives, p);
 result = best_multivariate_split_lda_with_pca(positives, negatives, w, w0, multivariate_type, newdim, variance_explained);
 *instances = positives;
 merge_instancelist(instances, negatives);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x45330
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movsd -0x30(%rbp), %xmm0
callq 0x6e550
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x44f40
movl -0x34(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: find_gain_for_partition_multivariate
double find_gain_for_partition_multivariate(Instanceptr* instances, Partition p, matrix* w, double* w0, MULTIVARIATE_TYPE multivariate_type, int* newdim, double variance_explained)
{
 /*!Last Changed 21.09.2004*/
 if (p.count == 0 || instances == NULL || all_same_side(p))
  {
   *w = identity(1);
   return ISELL;
  }
 if (!find_split_for_partition_multivariate(instances, p, w, w0, multivariate_type, newdim, variance_explained))
   return ISELL;
 return information_gain_for_multivariate_split(*instances, *w, *w0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
cmpl $0x0, 0x10(%rax)
je 0x6fbac
cmpq $0x0, -0x10(%rbp)
je 0x6fbac
movq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7a7f0
cmpl $0x0, %eax
je 0x6fbeb
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x1, %edi
callq 0x59f70
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movsd 0x72db4(%rip), %xmm0    # 0xe2998
movsd %xmm0, -0x8(%rbp)
jmp 0x6fc5d
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
movsd -0x38(%rbp), %xmm0
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x6faa0
cmpl $0x0, %eax
jne 0x6fc39
movsd 0x72d66(%rip), %xmm0    # 0xe2998
movsd %xmm0, -0x8(%rbp)
jmp 0x6fc5d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsd (%rcx), %xmm0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x6fa40
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: log_likelihood_for_multi_ldt_splits
double log_likelihood_for_multi_ldt_splits(Instanceptr data, matrix w, double w0)
{
 int counts[2][MAXCLASSES];
 double result = 0;
 find_counts_for_multivariate_split(data, w, w0, counts[0], counts[1]);
 result += log_likelihood_for_classification(counts[0]);
 result += log_likelihood_for_classification(counts[1]);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x1b8(%rbp)
movq -0x18(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
leaq -0x1b0(%rbp), %rcx
leaq -0x1b0(%rbp), %r8
addq $0xc8, %r8
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x6f960
leaq -0x1b0(%rbp), %rdi
callq 0x2ab10
addsd -0x1b8(%rbp), %xmm0
movsd %xmm0, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2ab10
addsd -0x1b8(%rbp), %xmm0
movsd %xmm0, -0x1b8(%rbp)
movsd -0x1b8(%rbp), %xmm0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/multivariatetree.c
// Function: create_multildtchildren
int create_multildtchildren(Decisionnodeptr node, Multildt_parameterptr param)
{
 /*!Last Changed 21.09.2004*/
 node->conditiontype = MULTIVARIATE_CONDITION;
 if (!(can_be_divided(node, &(param->c45param))))
   return 1;
 node->lineard = find_best_multi_ldt_split(&(node->instances),&(node->w),&(node->w0), MULTIVARIATE_LINEAR, param->variance_explained);
 if (!(node->lineard))
  {
   matrix_free(node->w);
   make_leaf_node(node);
   return 1;
  }
 node->featureno = LINEAR; 
 if (!(make_multivariate_children(node)))
   return 1;
 create_multildtchildren(node->left, param);
 create_multildtchildren(node->right, param);
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x98(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29340
cmpl $0x0, %eax
jne 0x701ec
movl $0x1, -0x4(%rbp)
jmp 0x7029d
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
movq -0x10(%rbp), %rdx
addq $0x48, %rdx
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x6fd20
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
jne 0x70253
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
movq -0x10(%rbp), %rdi
callq 0x28a30
movl $0x1, -0x4(%rbp)
jmp 0x7029d
movq -0x10(%rbp), %rax
movl $0xfffffffe, 0x30(%rax) # imm = 0xFFFFFFFE
movq -0x10(%rbp), %rdi
callq 0x6f570
cmpl $0x0, %eax
jne 0x70275
movl $0x1, -0x4(%rbp)
jmp 0x7029d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x701b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x701b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: node_in
int node_in(bayesiangraphptr mygraph, char *st)
{
 int i;
 for (i = 0; i < mygraph->nodecount; i++)
   if (strcmp(mygraph->nodes[i].name, st) == 0)
     return i;
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x7030c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x702ff
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x70313
jmp 0x70301
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x702c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: table_list
int* table_list(struct node mynode, int pos)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 int i, *result;
	result = (int *) safemalloc(mynode.parents * sizeof(int), "table_list", 2);
 for (i = mynode.parents - 1; i > -1; i--)
  {
   result[i] = pos % (mynode.parent_counts[i]);
   pos = pos / (mynode.parent_counts[i]);
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x4(%rbp)
movslq 0x20(%rax), %rdi
shlq $0x2, %rdi
leaq 0x76f0e(%rip), %rsi     # 0xe7250
movl $0x2, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movl 0x20(%rax), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jle 0x703a3
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
movq 0x18(%rcx), %rsi
movslq -0x8(%rbp), %rdi
cltd
idivl (%rsi,%rdi,4)
movl %edx, %esi
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rdx
movl %esi, (%rax,%rdx,4)
movl -0x4(%rbp), %eax
movq 0x18(%rcx), %rcx
movslq -0x8(%rbp), %rsi
cltd
idivl (%rcx,%rsi,4)
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x70360
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: table_pos
int table_pos(struct node mynode, int *list)
{
 int i, table_index = 0;
 for (i = 0; i < mynode.parents; i++)
   if (i != 0)
     table_index = list[i] + table_index * mynode.parent_counts[i];
   else
     table_index = list[0];
 return table_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x7041b
cmpl $0x0, -0xc(%rbp)
je 0x70405
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x10(%rbp), %ecx
movq 0x18(%rdx), %rdx
movslq -0xc(%rbp), %rsi
imull (%rdx,%rsi,4), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x7040e
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x70410
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x703ce
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: find_parents
int* find_parents(bayesiangraphptr mygraph, int node)
{
 /*!Last changed 15.01.2001*/
 int i = 0, where, *result = NULL;
 where = mygraph->nodes[node].pointer;
 while (where != -1)
  {
   i++;
   result = alloc(result, i * sizeof(int), i);
   result[i - 1] = mygraph->dest[where];
   where = mygraph->arcs[where].pointer;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x704b1
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rsi
shlq $0x2, %rsi
movl -0x10(%rbp), %edx
callq 0x52d10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
jmp 0x70457
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: parent_index
int parent_index(bayesiangraphptr mygraph, int node, int pindex)
{
 int i = 0, where;
 where = mygraph->nodes[node].pointer;
 while (i < pindex)
  {
   i++;
   where = mygraph->arcs[where].pointer;
  }
 return mygraph->dest[where];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x70513
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
jmp 0x704ee
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: add_one_node
nodeptr add_one_node(bayesiangraphptr mygraph, char *st)
{
/*!Last Changed 15.01.2001*/
 nodeptr current;
 mygraph->nodecount++;
 mygraph->nodes = alloc(mygraph->nodes, mygraph->nodecount * sizeof(struct node), mygraph->nodecount);
 current = &(mygraph->nodes[mygraph->nodecount - 1]);
 current->value_count = 0;
 current->parents = 0;
 current->table_count = 1;
 current->pointer = -1;
 current->name = strcopy(current->name, st);
 return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
imulq $0x48, %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x52d10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x1, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: find_arc_with_no
int find_arc_with_no(bayesiangraphptr mygraph, int arc_no, int *from, int *to, int *from_order, int *before)
{
/*!Last Changed 25.02.2001*/
 int i, pos1;
 for (i = 0; i < mygraph->nodecount; i++)
  {
   pos1 = mygraph->nodes[i].pointer;
   if (pos1 == -1)
     continue;
   *from_order = 0;
   *before = -1;
   if (pos1 == arc_no)
    {
     *to = i;
     *from = mygraph->dest[arc_no];
     return arc_no;
    }
   else
     while (mygraph->arcs[pos1].pointer != -1)
      {
       (*from_order)++;
       *before = pos1;
       if (mygraph->arcs[pos1].pointer == arc_no)
        {
         *from = mygraph->dest[arc_no];
         *to = i;
         return pos1;
        }
       pos1 = mygraph->arcs[pos1].pointer;
      }
  }
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x70713
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $-0x1, -0x40(%rbp)
jne 0x70646
jmp 0x70705
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl -0x40(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x7068b
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7071a
jmp 0x7068d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x40(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x70701
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x40(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x706ed
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7071a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
jmp 0x7068d
jmp 0x70703
jmp 0x70705
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x70612
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: modify_one_arc
void modify_one_arc(bayesiangraphptr G, int arc_no, int *from, int *to, int *from_order)
{
 /*!Last Changed 25.02.2001*/
 int before = -1;
 find_arc_with_no(G, arc_no, from, to, from_order, &before);
 if (before == -1)
   G->nodes[*to].pointer = G->arcs[arc_no].pointer;
 else
   G->arcs[before].pointer = G->arcs[arc_no].pointer;
 before = G->nodes[*from].pointer;
 if (before == -1)
   G->nodes[*from].pointer = arc_no;
 else
  {
   while (G->arcs[before].pointer != -1)
     before = G->arcs[before].pointer;
   G->arcs[before].pointer = arc_no;
  }
 G->arcs[arc_no].pointer = -1;
 G->dest[arc_no] = *to;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x2c(%rbp), %r9
callq 0x705f0
cmpl $-0x1, -0x2c(%rbp)
jne 0x7078e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdx
movslq (%rdx), %rdx
imulq $0x48, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x30(%rax)
jmp 0x707ac
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x707ec
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
imulq $0x48, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x30(%rax)
jmp 0x70826
jmp 0x707ee
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x70814
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
jmp 0x707ee
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: add_one_arc
Arcptr add_one_arc(bayesiangraphptr mygraph)
{
/*!Last Changed 25.02.2001*/
 mygraph->arccount++;
 mygraph->arcs = alloc(mygraph->arcs, mygraph->arccount * sizeof(struct arc), mygraph->arccount);
 mygraph->dest = alloc(mygraph->dest, mygraph->arccount * sizeof(int), mygraph->arccount);
 mygraph->arcs[mygraph->arccount - 1].pointer = -1;
 return &mygraph->arcs[mygraph->arccount - 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rsi
shlq $0x2, %rsi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
callq 0x52d10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rsi
shlq $0x2, %rsi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
callq 0x52d10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: add_one_pointer
void add_one_pointer(bayesiangraphptr mygraph, nodeptr src, int dest)
{
 /*!Last Changed 23.12.2000*/
 int where;
 if (src->pointer == -1)
   src->pointer = mygraph->arccount - 1;
 else
  {
   where = src->pointer;
   while (mygraph->arcs[where].pointer != -1)
     where = mygraph->arcs[where].pointer;
   mygraph->arcs[where].pointer = mygraph->arccount - 1;
  }
 mygraph->dest[mygraph->arccount - 1] = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x70b4c
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
jmp 0x70b95
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x70b7c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
jmp 0x70b56
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
subl $0x1, %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: delete_parent_counts
void delete_parent_counts(nodeptr Node, int parent_order)
{ /*Delete one parent from the parent_counts array*/
/*!Last Changed 25.02.2001*/
 int i;
 Node->table_count/=Node->parent_counts[parent_order];
 for (i=parent_order;i<Node->parents-1;i++)
   Node->parent_counts[i]=Node->parent_counts[i+1];
 Node->parents--;/*Yer kucultmede alloc yapma*/
 Node->parent_counts = alloc(Node->parent_counts, Node->parents * sizeof(int), Node->parents);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movslq (%rax,%rcx,4), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x28(%rax), %rax
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x70c40
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x70c01
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rsi
shlq $0x2, %rsi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
callq 0x52d10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: add_parent_counts
void add_parent_counts(bayesiangraphptr mygraph,nodeptr Node,int parent)
{ /*Add one parent in the parent_counts array*/
/*!Last Changed 23.12.2000*/
 Node->parents++;
 Node->parent_counts=alloc(Node->parent_counts,Node->parents*sizeof(int),Node->parents);
 Node->parent_counts[Node->parents-1]=mygraph->nodes[parent].value_count;
 Node->table_count*=mygraph->nodes[parent].value_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rsi
shlq $0x2, %rsi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
callq 0x52d10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
imulq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: add_one_value
void add_one_value(nodeptr current,char *st)
{/*Verilmis bir node a bir deger ekliyor*/
/*!Last Changed 15.01.2001*/
 current->value_count++;
 current->values=alloc(current->values,current->value_count*sizeof(char *),current->value_count);
 current->values[current->value_count-1]=strcopy(current->values[current->value_count-1],st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rsi
shlq $0x3, %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x52d10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/network.c
// Function: find_parent_order
int find_parent_order(bayesiangraphptr G,int parent,int node)
{
/* parentin nodeun kacinci parenti olduguna doner,
   eger parent bulunamazsa -1 e doner */
/*!Last Changed 03.01.2001*/
 int where=G->nodes[node].pointer,order=-1;
 while (where!=-1)
  {
   order++;
   if (G->dest[where]==parent)
     return order;
   where=G->arcs[where].pointer;
  }
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
cmpl $-0x1, -0x1c(%rbp)
je 0x70e7d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x70e69
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x70e84
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
jmp 0x70e3e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)