LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: find_counts_for_split
void find_counts_for_split(Instanceptr instances, int fno, double split, int* leftcounts, int* rightcounts, int conditiontype)
{
 /*!Last Changed 23.09.2004 added hybridcondition*/
 /*!Last Changed 09.02.2003*/
 int j;
 double value;
 Instanceptr tmp = instances;
 for (j = 0; j < MAXCLASSES; j++)
  {
   leftcounts[j] = 0;
   rightcounts[j] = 0;
  }
 while (tmp)
  {
   if (conditiontype != HYBRID_CONDITION)
     if (current_dataset->features[fno].type==INTEGER)
       value = tmp->values[fno].intvalue;
     else
       value = tmp->values[fno].floatvalue;
   else
     value = real_feature(tmp, fno);
   j = give_classno(tmp);
   if (value <= split)
     leftcounts[j]++;
   else
     rightcounts[j]++;
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x32, -0x30(%rbp)
jge 0xdd93e
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xdd90f
jmp 0xdd940
cmpq $0x0, -0x40(%rbp)
je 0xdda04
cmpl $0x2, -0x2c(%rbp)
je 0xdd9a2
leaq 0x27ee8(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0xdd98b
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0xdd9a0
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0xdd9b3
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x43530
movl %eax, -0x30(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xdd9e2
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0xdd9f3
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xdd940
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: find_split_for_partition
double find_split_for_partition(Instanceptr instances, Partition p, int fno, int conditiontype)
{
/*!Last Changed 29.12.2003*/
 int nl = 0, nr = 0;
 double ml, mr, sr, sl;
 if (p.count == 0 || instances == NULL || fno < 0 || all_same_side(p))
   return ISELL;
 left_and_right_sum(instances, p, fno, &ml, &mr, &nl, &nr, conditiontype);
 if (nl > 0)
   ml /= nl;
 else
   return ISELL;
 if (nr > 0)
   mr /= nr;
 else
   return ISELL;
 left_and_right_variance(instances, p, fno, &sl, &sr, ml, mr, conditiontype);
 if (nl > 1)
   sl /= (nl-1);
 else
   sl = 0;
 if (nr > 1)
   sr /= (nr-1);
 else
   sr = 0;
 return solve_for_ldt_second_order_equation(ml, mr, sl, sr, nl, nr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, 0x10(%rax)
je 0xdea92
cmpq $0x0, -0x10(%rbp)
je 0xdea92
cmpl $0x0, -0x14(%rbp)
jl 0xdea92
movq -0x48(%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 0xdeaa4
movsd 0x3efe(%rip), %xmm0     # 0xe2998
movsd %xmm0, -0x8(%rbp)
jmp 0xdebf1
movq -0x48(%rbp), %r10
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %eax
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x1c(%rbp), %r8
leaq -0x20(%rbp), %r9
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x8(%rsp)
movq 0x10(%r10), %r10
movq %r10, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0xdda10
cmpl $0x0, -0x1c(%rbp)
jle 0xdeaff
cvtsi2sdl -0x1c(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xdeb11
movsd 0x3e91(%rip), %xmm0     # 0xe2998
movsd %xmm0, -0x8(%rbp)
jmp 0xdebf1
cmpl $0x0, -0x20(%rbp)
jle 0xdeb2c
cvtsi2sdl -0x20(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xdeb3e
movsd 0x3e64(%rip), %xmm0     # 0xe2998
movsd %xmm0, -0x8(%rbp)
jmp 0xdebf1
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movl -0x18(%rbp), %r8d
leaq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xddfc0
cmpl $0x1, -0x1c(%rbp)
jle 0xdeb9d
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd -0x40(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xdeba5
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
cmpl $0x1, -0x20(%rbp)
jle 0xdebc5
movl -0x20(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0xdebcd
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0xde190
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: log_likelihood_for_uni_ldt_splits
double log_likelihood_for_uni_ldt_splits(Instanceptr data, int fno, double split, int conditiontype)
{
 /*!Last Changed 22.11.2004*/
 int counts[2][MAXCLASSES];
 double result = 0;
 find_counts_for_split(data, fno, split, counts[0], counts[1], conditiontype);
 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 %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x1b8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
leaq -0x1b0(%rbp), %rdx
leaq -0x1b0(%rbp), %rcx
addq $0xc8, %rcx
movl -0x1c(%rbp), %r8d
callq 0xdd8e0
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
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_univariate1
double decisiontree_vc_dimension_univariate1(double* testdata)
{
 /*Last Changed 01.10.2006*/
 const double mean[3] = {77.871900,3.053800,25.500000};
 const double variance[3] = {3066.280443,1.307234,208.458458};
 const double weights0[4] = {75.767898 ,45.757710 ,1.083343 ,3.206944 };
 double sum, weights_j, x_j, output;
 int i, j;
 double testdataconverted[3];
 for (i = 0; i < 3; i++)
   testdataconverted[i] = (testdata[i] - mean[i]) / sqrt(variance[i]);
 sum = weights0[0];
 for (j = 1; j < 4; j++)
  {
   weights_j = weights0[j];
   x_j = testdataconverted[j - 1];
   sum = sum + weights_j * x_j;
  }
 output = sum;
 return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq 0xf1ea(%rip), %rax      # 0xeeb70
movq %rax, -0x20(%rbp)
movq 0xf1e7(%rip), %rax      # 0xeeb78
movq %rax, -0x18(%rbp)
movq 0xf1e4(%rip), %rax      # 0xeeb80
movq %rax, -0x10(%rbp)
movq 0xf1e9(%rip), %rax      # 0xeeb90
movq %rax, -0x40(%rbp)
movq 0xf1e6(%rip), %rax      # 0xeeb98
movq %rax, -0x38(%rbp)
movq 0xf1e3(%rip), %rax      # 0xeeba0
movq %rax, -0x30(%rbp)
movq 0xf228(%rip), %rax      # 0xeebf0
movq %rax, -0x60(%rbp)
movq 0xf225(%rip), %rax      # 0xeebf8
movq %rax, -0x58(%rbp)
movq 0xf222(%rip), %rax      # 0xeec00
movq %rax, -0x50(%rbp)
movq 0xf21f(%rip), %rax      # 0xeec08
movq %rax, -0x48(%rbp)
movl $0x0, -0x84(%rbp)
cmpl $0x3, -0x84(%rbp)
jge 0xdfa67
movq -0x8(%rbp), %rax
movslq -0x84(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x84(%rbp), %rax
subsd -0x20(%rbp,%rax,8), %xmm0
movsd %xmm0, -0xa8(%rbp)
movslq -0x84(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0xa8(%rbp), %xmm0
divsd %xmm1, %xmm0
movslq -0x84(%rbp), %rax
movsd %xmm0, -0xa0(%rbp,%rax,8)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0xdf9f7
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movl $0x1, -0x88(%rbp)
cmpl $0x4, -0x88(%rbp)
jge 0xdfadc
movslq -0x88(%rbp), %rax
movsd -0x60(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x70(%rbp)
movl -0x88(%rbp), %eax
subl $0x1, %eax
cltq
movsd -0xa0(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x68(%rbp), %xmm1
movsd -0x70(%rbp), %xmm0
movsd -0x78(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xdfa7b
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x80(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_linear1
double decisiontree_vc_dimension_linear1(double* testdata)
{
 /*Last Changed 01.10.2006*/
 const double mean[3] = {267.750000,10.500000,25.500000};
 const double variance[3] = {51556.243744,33.283283,208.458458};
 const double weights0[4] = {85.843669 ,47.643896 ,2.714944 ,11.436310 };
 double sum, weights_j, x_j, output;
 int i, j;
 double testdataconverted[3];
 for (i = 0; i < 3; i++)
   testdataconverted[i] = (testdata[i] - mean[i]) / sqrt(variance[i]);
 sum = weights0[0];
 for (j = 1; j < 4; j++)
  {
   weights_j = weights0[j];
   x_j = testdataconverted[j - 1];
   sum = sum + weights_j * x_j;
  }
 output = sum;
 return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq 0xf09a(%rip), %rax      # 0xeebb0
movq %rax, -0x20(%rbp)
movq 0xf097(%rip), %rax      # 0xeebb8
movq %rax, -0x18(%rbp)
movq 0xf094(%rip), %rax      # 0xeebc0
movq %rax, -0x10(%rbp)
movq 0xf099(%rip), %rax      # 0xeebd0
movq %rax, -0x40(%rbp)
movq 0xf096(%rip), %rax      # 0xeebd8
movq %rax, -0x38(%rbp)
movq 0xf093(%rip), %rax      # 0xeebe0
movq %rax, -0x30(%rbp)
movq 0xf0b8(%rip), %rax      # 0xeec10
movq %rax, -0x60(%rbp)
movq 0xf0b5(%rip), %rax      # 0xeec18
movq %rax, -0x58(%rbp)
movq 0xf0b2(%rip), %rax      # 0xeec20
movq %rax, -0x50(%rbp)
movq 0xf0af(%rip), %rax      # 0xeec28
movq %rax, -0x48(%rbp)
movl $0x0, -0x84(%rbp)
cmpl $0x3, -0x84(%rbp)
jge 0xdfbf7
movq -0x8(%rbp), %rax
movslq -0x84(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x84(%rbp), %rax
subsd -0x20(%rbp,%rax,8), %xmm0
movsd %xmm0, -0xa8(%rbp)
movslq -0x84(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0xa8(%rbp), %xmm0
divsd %xmm1, %xmm0
movslq -0x84(%rbp), %rax
movsd %xmm0, -0xa0(%rbp,%rax,8)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0xdfb87
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movl $0x1, -0x88(%rbp)
cmpl $0x4, -0x88(%rbp)
jge 0xdfc6c
movslq -0x88(%rbp), %rax
movsd -0x60(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x70(%rbp)
movl -0x88(%rbp), %eax
subl $0x1, %eax
cltq
movsd -0xa0(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x68(%rbp), %xmm1
movsd -0x70(%rbp), %xmm0
movsd -0x78(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xdfc0b
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x80(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_preestimation
int decisiontree_vc_dimension_preestimation(Datasetptr d, int nodecount, MODEL_TYPE nodetype)
{
 /*Last Changed 06.11.2007*/
 int dim = d->multifeaturecount - 1;
 switch (nodetype)
  {
   case MODEL_UNI:return (nodecount + 1) * (log2(dim + 1) + 1) / 2;
                  break;
   case MODEL_LIN:return nodecount * (dim + 1);
                  break;
   case MODEL_QUA:return nodecount * (((dim + 1) * (dim + 2)) / 2);
                  break;
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %eax
decl %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0xdffc4
jmp 0xdffad
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0xe000f
jmp 0xdffb7
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0xe0020
jmp 0xe004a
movl -0x14(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x52ad0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd 0x2026(%rip), %xmm2     # 0xe2018
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x2c9e(%rip), %xmm1     # 0xe2ca0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0xe0051
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xe0051
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xe0051
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_discrete_old
double decisiontree_vc_dimension_discrete_old(Datasetptr d, Decisionnodeptr rootnode)
{
 /*!Last Changed 04.11.2009*/
 int D, N;
 if (rootnode->featureno == LEAF_NODE)
   return 1;
 D = d->featurecount - 1;
 N = decisiontree_node_count(rootnode);
 return 0.6734 + 1.0117 * N + 0.1939 * log2(D - log2(N)) * N + 0.7147 * log2(D - log2(N));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xe008c
movsd 0x1f96(%rip), %xmm0     # 0xe2018
movsd %xmm0, -0x8(%rbp)
jmp 0xe0154
movq -0x10(%rbp), %rax
movl 0x1bc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x28de0
movl %eax, -0x20(%rbp)
cvtsi2sdl -0x20(%rbp), %xmm0
movsd 0xea83(%rip), %xmm1     # 0xeeb38
mulsd %xmm1, %xmm0
movsd 0xea7f(%rip), %xmm1     # 0xeeb40
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x20(%rbp), %xmm0
callq 0x52ad0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
subsd %xmm1, %xmm0
callq 0x52ad0
movsd -0x38(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd 0xea31(%rip), %xmm0     # 0xeeb30
mulsd %xmm2, %xmm0
cvtsi2sdl -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x20(%rbp), %xmm0
callq 0x52ad0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
callq 0x52ad0
movsd -0x28(%rbp), %xmm1
movsd 0xe9e1(%rip), %xmm2     # 0xeeb28
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_discrete_recursive_old
double decisiontree_vc_dimension_discrete_recursive_old(int d, Decisionnodeptr rootnode)
{
 /*Last Changed 20.04.2008*/
 int N;
 double leftplusright;
 if (rootnode->featureno == LEAF_NODE)
   return 1;
 N = decisiontree_node_count(rootnode);
 leftplusright = decisiontree_vc_dimension_discrete_recursive_old(d - 1, &(rootnode->string[0])) + decisiontree_vc_dimension_discrete_recursive_old(d - 1, &(rootnode->string[1]));
 return 0.6076 + 1.0077 * leftplusright + 0.3657 * log2(d) - 0.8058 * log2(N);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xe018b
movsd 0x1e97(%rip), %xmm0     # 0xe2018
movsd %xmm0, -0x8(%rbp)
jmp 0xe0244
movq -0x18(%rbp), %rdi
callq 0x28de0
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
subl $0x1, %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xe0160
movsd %xmm0, -0x40(%rbp)
movl -0xc(%rbp), %edi
subl $0x1, %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x160, %rsi            # imm = 0x160
callq 0xe0160
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0xe971(%rip), %xmm1     # 0xeeb58
mulsd %xmm1, %xmm0
movsd 0xe96d(%rip), %xmm1     # 0xeeb60
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x52ad0
movsd -0x38(%rbp), %xmm1
movsd 0xe93d(%rip), %xmm2     # 0xeeb50
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
callq 0x52ad0
movsd -0x30(%rbp), %xmm1
movsd 0xe911(%rip), %xmm2     # 0xeeb48
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_continuous_recursive
double decisiontree_vc_dimension_continuous_recursive(Datasetptr current_dataset, Decisionnodeptr rootnode)
{
 if (rootnode->featureno == LEAF_NODE)
   return 1;
 if (rootnode->left->featureno == LEAF_NODE && rootnode->right->featureno == LEAF_NODE)
   return log2(current_dataset->featurecount - 1) + 1;
 return decisiontree_vc_dimension_continuous_recursive(current_dataset, rootnode->left) + decisiontree_vc_dimension_continuous_recursive(current_dataset, rootnode->right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xe0459
movsd 0x1bc6(%rip), %xmm0     # 0xe2018
movsd %xmm0, -0x8(%rbp)
jmp 0xe04d4
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xe049d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xe049d
movq -0x10(%rbp), %rax
movl 0x1bc(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x52ad0
movsd 0x1b86(%rip), %xmm1     # 0xe2018
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xe04d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xe0430
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xe0430
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_recursive
int decisiontree_vc_dimension_recursive(Datasetptr current_dataset, Decisionnodeptr root)
{
 if (number_of_symbolic_features(current_dataset->name) == current_dataset->featurecount - 1)
   return (int) decisiontree_vc_dimension_discrete_recursive(current_dataset, current_dataset->featurecount - 1, root);
 else
   if (number_of_numeric_features(current_dataset->name) == current_dataset->featurecount - 1)
     return decisiontree_vc_dimension_continuous_recursive(current_dataset, root);
   else
     return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1dd80
movq -0x10(%rbp), %rcx
movl 0x1bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xe0531
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1bc(%rax), %esi
subl $0x1, %esi
movq -0x18(%rbp), %rdx
callq 0xe0250
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0xe056c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1def0
movq -0x10(%rbp), %rcx
movl 0x1bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xe0565
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe0430
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0xe056c
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/vc.c
// Function: omnivariatetree_vc_dimension
int omnivariatetree_vc_dimension(Datasetptr d, Decisionnodeptr node)
{
 /*Last Changed 29.09.2006*/
 /*Last Changed 06.03.2006*/
 int uni, linear, quadratic, result = 0;
 uni = decisiontree_univariate_node_count(node);
 result += decisiontree_vc_dimension_wrt_nodetype(d, uni, MODEL_UNI);
 linear = decisiontree_multivariate_linear_node_count(node);
 result += decisiontree_vc_dimension_wrt_nodetype(d, linear, MODEL_LIN);
 quadratic = decisiontree_multivariate_quadratic_node_count(node);
 result += decisiontree_vc_dimension_wrt_nodetype(d, quadratic, MODEL_QUA);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdba00
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0xe0580
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6df20
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0x1, %edx
callq 0xe0580
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6dfb0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x2, %edx
callq 0xe0580
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: ruleset_vc_dimension_discrete
int ruleset_vc_dimension_discrete(Datasetptr current_dataset, Rulesetptr ruleset)
{
 int *condition_counts;
 int i = 0, vc, d;
 Decisionruleptr rule;
 d = current_dataset->featurecount - 1;
 rule = ruleset->start;
 condition_counts = safemalloc(ruleset->rulecount * sizeof(int), "ruleset_vc_dimension_discrete", 6);
 while (rule)
  {
   condition_counts[i] = rule->decisioncount;
   rule = rule->next;
   i++;
  }
 vc = ruleset_vc_dimension_discrete_recursive(condition_counts, ruleset->rulecount, d);
 safe_free(condition_counts);
 return vc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1bc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0xe2fa(%rip), %rsi      # 0xeec7f
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xe09c3
movq -0x30(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe0993
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movl -0x24(%rbp), %edx
callq 0xe0790
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52e80
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: ruleset_vc_dimension_continuous
int ruleset_vc_dimension_continuous(Datasetptr current_dataset, Rulesetptr ruleset)
{
 int sum = 0, d;
 Decisionruleptr rule;
 d = current_dataset->featurecount - 1;
 rule = ruleset->start;
 while (rule)
  {
   if (rule->decisioncount < 2)
     sum += 2;
   else
     sum += (int) (log2(binomdouble(d - 1, rule->decisioncount - 2) + 1) + 1);
   rule = rule->next;
  }
 return sum;
}

// 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
movl 0x1bc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe0a88
movq -0x20(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jge 0xe0a3e
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0xe0a7a
movl -0x18(%rbp), %edi
subl $0x1, %edi
movq -0x20(%rbp), %rax
movl 0x28(%rax), %esi
subl $0x2, %esi
callq 0x52c00
movsd 0x15bd(%rip), %xmm1     # 0xe2018
addsd %xmm1, %xmm0
callq 0x52ad0
movsd 0x15ac(%rip), %xmm1     # 0xe2018
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe0a22
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/vc.c
// Function: ruleset_vc_dimension
int ruleset_vc_dimension(Datasetptr current_dataset, Rulesetptr ruleset)
{
 if (number_of_symbolic_features(current_dataset->name) == current_dataset->featurecount - 1)
   return ruleset_vc_dimension_discrete(current_dataset, ruleset);
 else
    if (number_of_numeric_features(current_dataset->name) == current_dataset->featurecount - 1)
      return ruleset_vc_dimension_continuous(current_dataset, ruleset);
    else
      return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1dd80
movq -0x10(%rbp), %rcx
movl 0x1bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xe0ae0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe0940
movl %eax, -0x4(%rbp)
jmp 0xe0b17
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1def0
movq -0x10(%rbp), %rcx
movl 0x1bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xe0b10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe09f0
movl %eax, -0x4(%rbp)
jmp 0xe0b17
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_document
Xmldocumentptr xml_document(char* filename)
{
 Xmldocumentptr xml;
 if (!fileexists(filename))
   return NULL;
 xml = safemalloc(sizeof(Xmldocument), "xml_document", 2);
 xml->filename = strcopy(xml->filename, filename);
 xml->root = NULL;
 return xml;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x511b0
cmpl $0x0, %eax
jne 0xe0b44
movq $0x0, -0x8(%rbp)
jmp 0xe0b8c
movl $0x10, %edi
leaq 0xe270(%rip), %rsi      # 0xeedc0
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
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
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_read_token
char* xml_read_token(FILE* infile, char prevchar, char* nextchar, int space_allowed)
{
 char buffer[MAXTOKENLENGTH];
 char* token = NULL;
 int i;
 char ch = prevchar;
 i = 0;
 while ((ch != '\'') && (ch != '\"') && (ch != '=') && (ch != ' ' || space_allowed) && (ch != '/') && (ch != EOF) && (ch != '<') && (ch != '>'))
  {
   buffer[i] = ch;
   i++;
   ch = fgetc(infile);
  }
 buffer[i] = '\0';
 *nextchar = ch;
 token = strcopy(token, buffer);
 return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x58(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x5d(%rbp)
movl $0x0, -0x5c(%rbp)
movsbl -0x5d(%rbp), %ecx
xorl %eax, %eax
cmpl $0x27, %ecx
movb %al, -0x5e(%rbp)
je 0xe0c43
movsbl -0x5d(%rbp), %ecx
xorl %eax, %eax
cmpl $0x22, %ecx
movb %al, -0x5e(%rbp)
je 0xe0c43
movsbl -0x5d(%rbp), %ecx
xorl %eax, %eax
cmpl $0x3d, %ecx
movb %al, -0x5e(%rbp)
je 0xe0c43
movsbl -0x5d(%rbp), %eax
cmpl $0x20, %eax
jne 0xe0c0c
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x5e(%rbp)
je 0xe0c43
movsbl -0x5d(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0x5e(%rbp)
je 0xe0c43
movsbl -0x5d(%rbp), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x5e(%rbp)
je 0xe0c43
movsbl -0x5d(%rbp), %ecx
xorl %eax, %eax
cmpl $0x3c, %ecx
movb %al, -0x5e(%rbp)
je 0xe0c43
movsbl -0x5d(%rbp), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x5e(%rbp)
movb -0x5e(%rbp), %al
testb $0x1, %al
jne 0xe0c4c
jmp 0xe0c71
movb -0x5d(%rbp), %cl
movslq -0x5c(%rbp), %rax
movb %cl, -0x50(%rbp,%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4180
movb %al, -0x5d(%rbp)
jmp 0xe0bce
movslq -0x5c(%rbp), %rax
movb $0x0, -0x50(%rbp,%rax)
movb -0x5d(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x54ba0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_parse_tag
char* xml_parse_tag(FILE* infile, XML_TOKEN_TYPE* tokentype)
{
 char* token;
 char ch;
 ch = fgetc(infile);
 if (ch == '/')
  {
   *tokentype = XML_CLOSING_TAG_WITHOUT_ATTRIBUTES;
   ch = fgetc(infile);
  }
 else
   *tokentype = XML_OPENING_TAG_WITH_ATTRIBUTES;
 token = xml_read_token(infile, ch, &ch, BOOLEAN_FALSE);
 if (ch == '>' && *tokentype == XML_OPENING_TAG_WITH_ATTRIBUTES)
   *tokentype = XML_OPENING_TAG_WITHOUT_ATTRIBUTES;
 if (*tokentype == XML_CLOSING_TAG_WITHOUT_ATTRIBUTES && ch != '>')
  {
   printf(x1001);
   *tokentype = XML_END;
   return NULL;
  }
 else
   return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x2f, %eax
jne 0xe0cdd
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4180
movb %al, -0x21(%rbp)
jmp 0xe0ce7
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rdx
xorl %ecx, %ecx
movsbl -0x21(%rbp), %esi
callq 0xe0ba0
movq %rax, -0x20(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x3e, %eax
jne 0xe0d1a
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xe0d1a
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xe0d4e
movsbl -0x21(%rbp), %eax
cmpl $0x3e, %eax
je 0xe0d4e
leaq 0xe09a(%rip), %rdi      # 0xeedcd
movb $0x0, %al
callq 0x4030
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xe0d56
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_parse_attribute_value
char* xml_parse_attribute_value(FILE* infile, XML_TOKEN_TYPE* tokentype)
{
 char* token;
 char ch;
 ch = fgetc(infile);
 if (ch == '\'' || ch == '\"')
  {
   *tokentype = XML_ATTRIBUTE_VALUE;
   return NULL;
  }
 token = xml_read_token(infile, ch, &ch, BOOLEAN_TRUE);
 if (ch != '\'' && ch != '\"')
  {
   printf(x1002);
   *tokentype = XML_END;
   return NULL;
  }
 *tokentype = XML_ATTRIBUTE_VALUE;
 return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x27, %eax
je 0xe0d8e
movsbl -0x21(%rbp), %eax
cmpl $0x22, %eax
jne 0xe0da2
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xe0e02
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movl $0x1, %ecx
movsbl -0x21(%rbp), %esi
callq 0xe0ba0
movq %rax, -0x20(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x27, %eax
je 0xe0df0
movsbl -0x21(%rbp), %eax
cmpl $0x22, %eax
je 0xe0df0
leaq 0xe030(%rip), %rdi      # 0xeee05
movb $0x0, %al
callq 0x4030
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xe0e02
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_parse_empty_tag
char* xml_parse_empty_tag(FILE* infile, XML_TOKEN_TYPE* tokentype)
{
 char ch;
 ch = fgetc(infile);
 if (ch != '>')
  {
   printf(x1001);
   *tokentype = XML_END;
  }
 else
   *tokentype = XML_CLOSING_TAG_WITH_ATTRIBUTES;
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4180
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3e, %eax
je 0xe0e4f
leaq 0xdf91(%rip), %rdi      # 0xeedcd
movb $0x0, %al
callq 0x4030
movq -0x10(%rbp), %rax
movl $0x8, (%rax)
jmp 0xe0e59
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_get_next_token
char* xml_get_next_token(FILE* infile, XML_TOKEN_TYPE* tokentype)
{
 char ch;
 char* token;
 /*Skip spaces*/
 ch = fgetc(infile);
 while (ch == ' ' || ch == '\t' || ch == '\n')
   ch = fgetc(infile);
 switch (ch){
   case  '<':return xml_parse_tag(infile, tokentype);
             break;
   case '\"':
   case '\'':return xml_parse_attribute_value(infile, tokentype);
             break;
   case  '/':return xml_parse_empty_tag(infile, tokentype);
             break;
   case  '=':*tokentype = XML_EQUAL;             
             break;
   case  '>':*tokentype = XML_OPENING_TAG_FINISH;
             return NULL;
             break;
   case  EOF:*tokentype = XML_END;
             return NULL;
   default  :token = xml_read_token(infile, ch, &ch, BOOLEAN_TRUE);
             *tokentype = XML_TEXT;
             ungetc(ch, infile);
             return token;
             break;
 }
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x29(%rbp)
je 0xe0eb5
movsbl -0x19(%rbp), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x29(%rbp)
je 0xe0eb5
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xe0ebe
jmp 0xe0ecc
movq -0x10(%rbp), %rdi
callq 0x4180
movb %al, -0x19(%rbp)
jmp 0xe0e8c
movsbl -0x19(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x3f, %eax
ja 0xe0f68
movq -0x38(%rbp), %rax
leaq 0xddb4(%rip), %rcx      # 0xeeca0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe0ca0
movq %rax, -0x8(%rbp)
jmp 0xe0fab
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe0d60
movq %rax, -0x8(%rbp)
jmp 0xe0fab
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe0e10
movq %rax, -0x8(%rbp)
jmp 0xe0fab
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
jmp 0xe0fa3
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xe0fab
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xe0fab
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movl $0x1, %ecx
movsbl -0x19(%rbp), %esi
callq 0xe0ba0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x7, (%rax)
movsbl -0x19(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4110
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe0fab
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xmlelement
Xmlelementptr xmlelement(char* name, Xmlelementptr parent, int has_attributes)
{
 Xmlelementptr element;
 element = safemalloc(sizeof(Xmlelement), "xmlelement", 2);
 if (has_attributes)
   element->attributes = link_list();
 else
   element->attributes = NULL;
 element->parent = parent;
 element->sibling = NULL;
 element->child = NULL;
 element->pcdata = NULL;
 element->name = strcopy(element->name, name);
 return element;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x30, %edi
leaq 0xde5f(%rip), %rsi      # 0xeee3e
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xe1007
movb $0x0, %al
callq 0x273e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xe1013
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_set_attribute_value
void xml_set_attribute_value(Xmlelementptr element, char* attribute_name, char* attribute_value)
{
 Listitemptr listnode;
 Xmlattributeptr att;
 if (element->attributes)
  {
   listnode = element->attributes->head;
   while (listnode && strIcmp(attribute_name, ((Xmlattributeptr)(listnode->item))->name) != 0)
     listnode = listnode->next;
   if (listnode)
    {
     att = (Xmlattributeptr)(listnode->item);
     safe_free(att->value);
     att->value = strcopy(att->value, attribute_value);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe111e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0xe10ca
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x54990
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xe10d3
jmp 0xe10e1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe10a2
cmpq $0x0, -0x20(%rbp)
je 0xe111c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe111e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_get_attribute_value
char* xml_get_attribute_value(Xmlelementptr element, char* attribute_name)
{
 Listitemptr listnode;
 if (element->attributes)
  {
   listnode = element->attributes->head;
   while (listnode && strIcmp(attribute_name, ((Xmlattributeptr)(listnode->item))->name) != 0)
     listnode = listnode->next;
   if (listnode)
     return ((Xmlattributeptr)(listnode->item))->value;
  }
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe11b3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0xe1182
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x54990
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xe118b
jmp 0xe1199
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe115a
cmpq $0x0, -0x20(%rbp)
je 0xe11b1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe11bb
jmp 0xe11b3
movq $0x0, -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/xmlparser.c
// Function: xml_number_of_children
int xml_number_of_children(Xmlelementptr element)
{
 int result = 0;
 Xmlelementptr childnode = element->child;
 while (childnode)
  {
   result++;
   childnode = childnode->sibling;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe1459
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe143b
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_number_of_children_with_specific_attribute_value
int xml_number_of_children_with_specific_attribute_value(Xmlelementptr element, char* attribute_name, char* attribute_value)
{
 int result = 0;
 Xmlelementptr childnode = element->child;
 while (childnode)
  {
   if (strIcmp(xml_get_attribute_value(childnode, attribute_name), attribute_value) == 0)
     result++;
   childnode = childnode->sibling;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe14c3
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe1130
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0xe14b5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xe1487
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_get_child_with_specific_attribute_value
Xmlelementptr xml_get_child_with_specific_attribute_value(Xmlelementptr element, char* attribute_name, char* attribute_value)
{
 Xmlelementptr childnode = element->child;
 while (childnode)
  {
   if (strIcmp(xml_get_attribute_value(childnode, attribute_name), attribute_value) == 0)
     return childnode;
   childnode = childnode->sibling;
  }
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe152d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe1130
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0xe151f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe1535
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xe14f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_get_child_with_name
Xmlelementptr xml_get_child_with_name(Xmlelementptr element, char* name)
{
 Xmlelementptr childnode = element->child;
 while (childnode)
  {
   if (strIcmp(childnode->name, name) == 0)
     return childnode;
   childnode = childnode->sibling;
  }
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe1590
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0xe1582
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe1598
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe155c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_free_attribute
void xml_free_attribute(void* attribute)
{
 Xmlattributeptr att = (Xmlattributeptr) attribute;
 safe_free(att->name);
 safe_free(att->value);
 safe_free(att);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x10(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/xmlparser.c
// Function: xml_free_element
void xml_free_element(Xmlelementptr element)
{
 if (element->attributes != NULL)
   free_link_list(element->attributes, xml_free_attribute);
 if (element->pcdata != NULL)
   safe_free(element->pcdata);
 if (element->child != NULL)
   xml_free_element(element->child);
 if (element->sibling != NULL)
   xml_free_element(element->sibling);
 safe_free(element->name);
 safe_free(element);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe161b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x66(%rip), %rsi       # 0xe15b0
callq 0x276a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe1633
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xe164b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xe15f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xe1663
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xe15f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/main.c
// Function: cubehash256
void cubehash256(char* input, char* output) {
    
    uint32_t result[8];
    sph_cubehash256_context ctx_cubehash;
    
    sph_cubehash256_init(&ctx_cubehash);
    sph_cubehash256(&ctx_cubehash, input, 32);
    sph_cubehash256_close(&ctx_cubehash, result);
    
    memcpy(output, result, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x42e10
movq -0x8(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
movl $0x20, %edx
callq 0x42e40
leaq -0x30(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x42e70
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/main.c
// Function: blake256
void blake256(char* input, char* output) {
    
    uint32_t result[8];
    sph_blake256_context ctx_blake;
    
    sph_blake256_init(&ctx_blake);
    sph_blake256(&ctx_blake, input, 32);
    sph_blake256_close(&ctx_blake, result);	
    
    memcpy(output, result, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1c430
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movl $0x20, %edx
callq 0x1c460
leaq -0x30(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x1c490
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/main.c
// Function: keccak256
void keccak256(char* input, char* output) {
    
    uint32_t result[8];
    sph_keccak256_context ctx_keccak;
    
    sph_keccak256_init(&ctx_keccak);
    sph_keccak256(&ctx_keccak, input, 32); 
    sph_keccak256_close(&ctx_keccak, result);
    
    memcpy(output, result, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4da30
movq -0x8(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movl $0x20, %edx
callq 0x4da50
leaq -0x30(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x4da80
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq