LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matvecmul
void matvecmul(matrix A, vector F)
/* matvecmul multiplies matrix A with vector F, the result is put in F */
{ int rowrunner, colrunner;
  double tmpval;
  double tmp;
  vector tmpv;
  int rows;
  int cols;
  rows=F->rows;
  cols=A->cols;
  tmpv=(vector)newvector(F->rows);
  for (rowrunner=1; rowrunner<=rows; rowrunner++)
  { tmpval = (double)0.0;
	for (colrunner=1; colrunner<=cols; colrunner++)
	  { tmp=(double)M(A,rowrunner,colrunner)*(double)V(F,colrunner);
		tmpval=tmpval+tmp;
	  }
	V(tmpv,rowrunner)=tmpval;
  }    
  for (rows=1; rows<=F->rows; rows++)
  { V(F,rows) = V(tmpv,rows);
  }
  delvector(tmpv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %r15d
movl 0x4(%rdi), %r12d
movl %r15d, %edi
callq 0xb358
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
testl %r15d, %r15d
cmovlel %ecx, %r15d
incl %r15d
pushq $0x1
popq %rcx
cmpq %r15, %rcx
je 0xb996
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %r12
je 0xb987
movq 0x8(%r14), %rsi
movq -0x8(%rsi,%rcx,8), %rsi
movsd (%rsi,%rdx,8), %xmm1
movq 0x8(%rbx), %rsi
mulsd (%rsi,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0xb962
movq 0x8(%rax), %rdx
movsd %xmm0, -0x8(%rdx,%rcx,8)
incq %rcx
jmp 0xb957
movl (%rbx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0xb9bb
movq 0x8(%rax), %rsi
movsd (%rsi,%rdx,8), %xmm0
movq 0x8(%rbx), %rsi
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0xb99f
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb43d
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: printmatrix
void printmatrix(matrix m, char *text)
{  int i,j;
   printf("  Printmatrix: %s\n",text);
   for (i=1; i<=m->rows; i+=1)
   {
	 { for (j=1; j<=m->cols; j+=1)
	    printf(" % 8.8E",M(m,i,j)); 
	     /*if ( (fabs(M(m,i  ,j  ))>1.0E-20) ||
			  (fabs(M(m,i  ,j+1))>1.0E-20) ||
			  (fabs(M(m,i  ,j+2))>1.0E-20) ||
	          (fabs(M(m,i+1,j  ))>1.0E-20) ||
			  (fabs(M(m,i+1,j+1))>1.0E-20) ||
			  (fabs(M(m,i+1,j+2))>1.0E-20) ||
	          (fabs(M(m,i+2,j  ))>1.0E-20) ||
			  (fabs(M(m,i+2,j+1))>1.0E-20) ||
			  (fabs(M(m,i+2,j+2))>1.0E-20) 
		    ) printf("#"); else printf("0");  */
	 }
	 printf("\n");
   }
   text=text;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x39f8(%rip), %rdi      # 0xf408
xorl %eax, %eax
callq 0x1090
pushq $0x1
popq %r15
pushq $0xa
popq %rbp
leaq 0x39f6(%rip), %r14      # 0xf41b
movq %r15, %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jg 0xba67
movq %r15, %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jg 0xba5b
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
movsd -0x8(%rax,%r13,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1090
incq %r13
jmp 0xba33
movl %ebp, %edi
callq 0x1040
incq %r12
jmp 0xba28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: printhypermatrix
void printhypermatrix(hypermatrix hm, char *text)
{ int i;
  printf("  printhypermatrix: %s\n",text);
  for (i=1; i<=hm->dimension; i++)
	{ printf("   dim: %d\n",i);
	  printmatrix(hm->data[i],"matrix");
    }
  text=text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x399b(%rip), %rdi      # 0xf423
xorl %eax, %eax
callq 0x1090
pushq $0x1
popq %r14
leaq 0x39a1(%rip), %r15      # 0xf43b
leaq 0x161e(%rip), %r12      # 0xd0bf
movslq (%rbx), %rax
cmpq %rax, %r14
jg 0xbacb
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1090
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq %r12, %rsi
callq 0xb9fb
incq %r14
jmp 0xbaa1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: printvector
void printvector(vector v, char *text)
{ int i;
  printf("  Printvector: %s\n",text);
  for (i=1; i<=v->rows; i++)
	printf(" %+8.8E\n",V(v,i));
  text=text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3961(%rip), %rdi      # 0xf447
xorl %eax, %eax
callq 0x1090
pushq $0x1
popq %r15
leaq 0x3962(%rip), %r14      # 0xf45a
movslq (%rbx), %rax
cmpq %rax, %r15
jg 0xbb1a
movq 0x8(%rbx), %rax
movsd -0x8(%rax,%r15,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1090
incq %r15
jmp 0xbaf8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrix.c
// Function: nn
void nn(int m, intvector nietnul,point po)
/* Zoekt de niet-nul kolommen op en slaat de index van deze kolommen
   op in de vector nietnul en een nul in het andere geval */
{
  int teller1,teller2;
  point thep;
  
  teller1=0; teller2=0;
  thep=(point)point_dll(po,START,0);
  
  while (thep!=(point)NULL)
    { 
      if (thep->type==CNODE)
	{ 
	  if (thep->label*3-3<m) 
	    { 
	      teller1++;	
	      V(nietnul,thep->label*3-3)=teller1;
	      teller1++;	
	      V(nietnul,thep->label*3-2)=teller1;
	      teller1++;	
	      V(nietnul,thep->label*3-1)=teller1;
	    }
	  else 
	    { 
	      teller2++;	
	      V(nietnul,thep->label*3-3)=teller2;  
	      teller2++;	
	      V(nietnul,thep->label*3-2)=teller2;  
	      teller2++;	
	      V(nietnul,thep->label*3-1)=teller2;  
	    }
	}  
      else
	{
	  V(nietnul,thep->label*3-3)=0;
	  V(nietnul,thep->label*3-2)=0;
	  V(nietnul,thep->label*3-1)=0;
	}
      thep=thep->NEXT;
    }
  
  p=teller1; /* aantal niet-nul kolommen in het linkergedeelte */
  q=teller2; /* aantal niet-nul kolommen in het rechtergedeelte */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r14d, %r14d
movq %rdx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
xorl %ecx, %ecx
testq %rax, %rax
je 0xbe87
cmpl $0xf, 0x14(%rax)
jne 0xbe35
movslq 0x10(%rax), %rdx
leaq (%rdx,%rdx,2), %rsi
leal -0x3(%rsi), %edi
movq 0x8(%rbx), %rdx
cmpl %ebp, %edi
jge 0xbe57
leal 0x1(%r14), %edi
movl %edi, -0xc(%rdx,%rsi,4)
leal 0x2(%r14), %esi
movslq 0x10(%rax), %rdi
imulq $0xc, %rdi, %rdi
movl %esi, -0x8(%rdx,%rdi)
addl $0x3, %r14d
movl %r14d, %esi
jmp 0xbe72
movq 0x8(%rbx), %rdx
movslq 0x10(%rax), %rsi
imulq $0xc, %rsi, %rsi
andl $0x0, -0xc(%rdx,%rsi)
movslq 0x10(%rax), %rsi
imulq $0xc, %rsi, %rsi
andl $0x0, -0x8(%rdx,%rsi)
xorl %esi, %esi
jmp 0xbe72
leal 0x1(%rcx), %edi
movl %edi, -0xc(%rdx,%rsi,4)
leal 0x2(%rcx), %esi
movslq 0x10(%rax), %rdi
imulq $0xc, %rdi, %rdi
movl %esi, -0x8(%rdx,%rdi)
addl $0x3, %ecx
movl %ecx, %esi
movslq 0x10(%rax), %rdi
imulq $0xc, %rdi, %rdi
movl %esi, -0x4(%rdx,%rdi)
movq 0x8(%rax), %rax
jmp 0xbdf2
movl %r14d, 0x8a52(%rip)     # 0x148e0
movl %ecx, 0x8a50(%rip)      # 0x148e4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrix.c
// Function: verwijdernullen
void verwijdernullen(int m,int n,matrix Ma, intvector nietnul,point po )
/* Transformeert de matrix M in een tweetal matrices N1 en N2 die ontstaan
   uit M door uit respectievelijk de bovenste helft en de onderste helft
   de nul-kolommen weg te halen */
{ 
  int i,j,k;
  
  nn(m, nietnul, po);
  
  /* We schuiven in het bovenste gedeelte de niet-nul kolommen naar 
     links */

  k=0;
  for (j=m;j<m+n;j++)
    {
      if (V(nietnul,j)!=0)
	{	
	  for (i=0;i<m;i++)	   
	    M(Ma,i,m+k)=M(Ma,i,j);	   	  
	  k++;
	}	
    }
  
  k=1;
  for (j=m-1;j>=0;j--)
    {
      if (V(nietnul,j)!=0)
	{	
	  for (i=0;i<n;i++)
	    M(Ma,m+i,m-k)=M(Ma,m+i,j); 
	  k++;
	}		
    } 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movl %edi, %r15d
movq %rcx, %rsi
movq %r8, %rdx
callq 0xbdd8
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
leal (%r12,%r15), %esi
movslq %r15d, %rax
movslq %esi, %rsi
movq %rax, %rdi
cmpq %rsi, %rdi
jge 0xbf12
movq 0x8(%rbx), %r8
cmpl $0x0, (%r8,%rdi,4)
je 0xbf0d
leal (%rcx,%r15), %r8d
movslq %r8d, %r8
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0xbf0b
movq 0x8(%r14), %r10
movq (%r10,%r9,8), %r10
movsd (%r10,%rdi,8), %xmm0
movsd %xmm0, (%r10,%r8,8)
incq %r9
jmp 0xbeed
incl %ecx
incq %rdi
jmp 0xbed3
xorl %ecx, %ecx
testl %r12d, %r12d
cmovgl %r12d, %ecx
movl %r15d, %edi
pushq $0x1
popq %rdx
testl %edi, %edi
jle 0xbf6c
leaq -0x1(%rdi), %rsi
movq 0x8(%rbx), %r8
cmpl $0x0, -0x4(%r8,%rdi,4)
movq %rsi, %rdi
je 0xbf21
movl %r15d, %edi
subl %edx, %edi
movslq %edi, %rdi
movq %rcx, %r8
movq %rax, %r9
subq $0x1, %r8
jb 0xbf65
movq 0x8(%r14), %r10
movq (%r10,%r9,8), %r10
movsd (%r10,%rsi,8), %xmm0
movsd %xmm0, (%r10,%rdi,8)
incq %r9
jmp 0xbf46
incl %edx
movq %rsi, %rdi
jmp 0xbf21
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/matrix.c
// Function: hetelement
double hetelement(int m, int i, int j, intvector nietnul, matrix Ma)
/* Bepaalt het hetelement (i,j) van de oorspronkelijke matrix M uit de nieuwe
   matrix Ma */
{  
  if (i<m)
    {	
      if (j<m) 
	return M(Ma,i,j);
      else	
	{
	  if (V(nietnul,j)!=0)
	    return M(Ma,i,m+V(nietnul,j)-1);
	  else	return 0;
	}	
    }
  else	
    {
      if (j>=m)
	{	
	  return M(Ma,i,j);
	}	
      else	
	{
	  if (V(nietnul,j)!=0)
	    return M(Ma,i,m-p+V(nietnul,j)-1);
	  else return 0;
	}	
    }
}

// Assembly:
cmpl %edi, %esi
jge 0xbf9d
cmpl %edi, %edx
jl 0xbfce
movq 0x8(%rcx), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
testl %eax, %eax
je 0xbfe5
movq 0x8(%r8), %rcx
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
addl %edi, %eax
jmp 0xbfc2
cmpl %edi, %edx
jge 0xbfce
movq 0x8(%rcx), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
testl %eax, %eax
je 0xbfe5
movq 0x8(%r8), %rcx
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
addl %edi, %eax
subl 0x891e(%rip), %eax      # 0x148e0
cltq
leaq (%rcx,%rax,8), %rax
addq $-0x8, %rax
jmp 0xbfe0
movq 0x8(%r8), %rcx
movslq %esi, %rsi
movslq %edx, %rax
shlq $0x3, %rax
addq (%rcx,%rsi,8), %rax
movsd (%rax), %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/memstat.c
// Function: mymalloc
const void *mymalloc(const size_t size)
{ const void *p; 
  if (size==0) fprintf(stderr,"MYMALLOC CALLED WITH 0 LENGTH!\n");
  p = (void *)malloc(size);
  current_allocated++;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc081
movq %rbx, %rdi
callq 0x1120
incl 0x8869(%rip)            # 0x148e8
popq %rbx
retq
movq 0x7f70(%rip), %rax      # 0x13ff8
movq (%rax), %rcx
leaq 0x33f2(%rip), %rdi      # 0xf484
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
jmp 0xc071
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/memstat.c
// Function: myfree
void myfree(void *p)
{ if (p==NULL) {
	fprintf(stderr,"MYFREE CALLED FOR SOMETHING THAT IS NOT ALLOCATED!\n"); 
	p=p;
  }
  free(p);
  current_allocated--;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc0b8
movq %rbx, %rdi
callq 0x1030
decl 0x8832(%rip)            # 0x148e8
popq %rbx
retq
movq 0x7f39(%rip), %rax      # 0x13ff8
movq (%rax), %rcx
leaq 0x33db(%rip), %rdi      # 0xf4a4
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
jmp 0xc0a8
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/points.c
// Function: newpoint
point newpoint( void )
{ point p;
  if ( (p=(point)mymalloc(sizeof(pointtype))) == (point)NULL )
    evaluate_level(RED,10);
  p->PREV=(point)NULL; p->NEXT=(point)NULL; p->label = -1;
  p->type=NODE; p->conn=0;
  return p;
}

// Assembly:
pushq %rbx
movl $0x88, %edi
callq 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xc12a
pushq $0x2
popq %rdi
pushq $0xa
popq %rsi
callq 0xb0f8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movabsq $0xbffffffff, %rax      # imm = 0xBFFFFFFFF
movq %rax, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/points.c
// Function: point_dll
point point_dll( point thedll, const int command, const int label )
{ point thecopy;
  /* make a copy of the incoming point for certain commands: */
  if ( (command==APPEND)||(command==NEW) )
  { thecopy=newpoint(); thecopy->label=-1; thecopy->x=0.0;
    thecopy->y=0.0; thecopy->z=0.0;
  }
  switch(command) {
    case START:  { while(thedll->PREV!=(point)NULL) thedll=thedll->PREV;
                   thedll=thedll->NEXT; /* because first item isn't used */
		   return thedll;
		 }
	case END:    { while((thedll!=(point)NULL)&&
	               (thedll->NEXT!=(point)NULL)) thedll=thedll->NEXT;
		   return thedll;
		 }
    case SEARCH: { thedll=point_dll(thedll,START,0);
		   while((thedll->label!=label)&&(thedll->NEXT!=(point)NULL))
		     thedll=thedll->NEXT;
		   if (thedll->label==label) return thedll;
		   else
		   {   evaluate_level(YELLOW,11);
			   return (point)NULL;
		   }
		 }
    case APPEND: { point_dll(thedll,END,0);
		   thedll->NEXT=thecopy;
		   thecopy->NEXT=(point)NULL;
		   thecopy->PREV=thedll;
		   return thecopy;
		 }
    case NEW:    { thecopy->PREV=(point)NULL;
		   thecopy->NEXT=(point)NULL;
		   return thecopy;
		 }
    case KILL:   { thedll=point_dll(thedll,END,0);
		   while(thedll->PREV!=(point)NULL)
		   { thedll=thedll->PREV;
		     myfree(thedll->NEXT);
		   }
		   myfree(thedll);
		   return (point)NULL;
		 }
    default:     { evaluate_level(YELLOW,12);
		 }
  } /* switch */
return (point)NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leal -0x3(%r15), %eax
cmpl $0x1, %eax
ja 0xc17c
callq 0xc10c
movq %rax, %rbx
orl $-0x1, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
cmpl $0x5, %r15d
ja 0xc23b
movl %r15d, %eax
leaq 0x3388(%rip), %rcx      # 0xf518
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rax
movq (%r14), %r14
testq %r14, %r14
jne 0xc199
movq 0x8(%rax), %rbx
jmp 0xc248
testq %r14, %r14
je 0xc246
movq %r14, %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xc1ad
jmp 0xc248
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xc248
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %rbx
cmpl %ebp, 0x10(%rbx)
je 0xc248
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xc1de
pushq $0x1
popq %rdi
pushq $0xb
jmp 0xc240
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc14c
movq %rbx, 0x8(%r14)
andq $0x0, 0x8(%rbx)
movq %r14, (%rbx)
jmp 0xc248
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc14c
movq (%rax), %rbx
testq %rbx, %rbx
je 0xc231
movq 0x8(%rbx), %rdi
callq 0xc09f
movq %rbx, %rax
jmp 0xc21b
movq %rax, %rdi
callq 0xc09f
jmp 0xc246
pushq $0x1
popq %rdi
pushq $0xc
popq %rsi
callq 0xb0f8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/restr.c
// Function: newrestraint
restraint newrestraint( void )
{ restraint r;
  if ( (r=(restraint)mymalloc(sizeof(restrainttype))) == (restraint)NULL )
    evaluate_level(RED,80);
  r->PREV=(restraint)NULL; r->NEXT=(restraint)NULL; r->label=0;
  return r;
}

// Assembly:
pushq %rbx
pushq $0x48
popq %rdi
callq 0xc068
movq %rax, %rbx
testq %rax, %rax
jne 0xc274
pushq $0x2
popq %rdi
pushq $0x50
popq %rsi
callq 0xb0f8
andl $0x0, 0x14(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/restr.c
// Function: fill_restraints
void fill_restraints(restraint r, FILE *fp)
{ char theKeyword[80];
  int type;
  double x;
  double y;
  double z;
  while(1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_TRACTIONS"))     return;
    if (!strcmp(theKeyword,"END_DISPLACEMENTS")) return;
    if (!strcmp(theKeyword,"END"))               return;
    type=r->type;
    r=(restraint)restraint_dll(r,APPEND,0);
    r->type  = type;
    r->label = atoi(theKeyword);

    read_keyword(fp,theKeyword); 
	  x = strtod(theKeyword,NULL);

    read_keyword(fp,theKeyword); 
	  y = strtod(theKeyword,NULL);
	  
    read_keyword(fp,theKeyword); 
	  z = strtod(theKeyword,NULL);

    /* if (r->type==TRACTION) */
    { r->f1 = x;
      r->f2 = y;
      r->f3 = z;
    }
    /* if (r->type==DISPLACEMENT) */
    { r->u1 = x;
      r->u2 = y;
      r->u3 = z;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x10(%rsp), %r14
leaq 0x32a5(%rip), %r15      # 0xf548
pushq $0xe
popq %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1140
testl %eax, %eax
je 0xc391
movq %r14, %rdi
leaq 0x3284(%rip), %rsi      # 0xf556
pushq $0x12
popq %rdx
callq 0x1140
testl %eax, %eax
je 0xc391
cmpl $0x444e45, 0x10(%rsp)   # imm = 0x444E45
je 0xc391
movl 0x10(%r13), %ebp
movq %r13, %rdi
pushq $0x3
popq %rsi
xorl %edx, %edx
callq 0xc3a0
movq %rax, %r13
movl %ebp, 0x10(%rax)
movq %r14, %rdi
callq 0x1170
movl %eax, 0x14(%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x18(%r13)
movsd (%rsp), %xmm2
movsd %xmm2, 0x20(%r13)
movsd %xmm0, 0x28(%r13)
movsd %xmm1, 0x30(%r13)
movsd %xmm2, 0x38(%r13)
movsd %xmm0, 0x40(%r13)
jmp 0xc2a7
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/restr.c
// Function: restraint_dll
restraint restraint_dll( restraint thedll, const int command, const int label )
{ restraint thecopy;
  /* make a copy of the incoming restraint for certain commands: */
  if ((command==APPEND)||(command==NEW)) thecopy=(restraint)newrestraint();
	switch(command) {
	case START:  { while(thedll->PREV!=(restraint)NULL) thedll=thedll->PREV;
				   thedll=thedll->NEXT;
				   return thedll;
				 }
	case END:    { while((thedll!=(restraint)NULL)&&
	               (thedll->NEXT!=(restraint)NULL)) thedll=thedll->NEXT;
				   return thedll;
				 }
	case SEARCH: { if (thedll->NEXT==NULL) return (restraint)NULL;
				   thedll=restraint_dll(thedll,START,0);
				   while((thedll->label!=label)&&(thedll->NEXT!=(restraint)NULL))
				   { thedll=thedll->NEXT;
				   }
				   if (thedll->label==label) return thedll;
				   else
				   {/*  evaluate_level(YELLOW,81); */
					 return (restraint)NULL;
				   }
				 }
	case APPEND: { thedll = restraint_dll(thedll,END,0);
				   thedll->NEXT=thecopy;
				   thecopy->PREV=thedll;
				   thecopy->NEXT=(restraint)NULL;
				   return thecopy;
				 }
	case NEW:    { thecopy->PREV=(restraint)NULL;
				   thecopy->NEXT=(restraint)NULL;
				   return thecopy;
				 }
	case KILL:   { thedll=restraint_dll(thedll,END,0);
				   while(thedll->PREV!=(restraint)NULL)
				   { thedll=thedll->PREV;
					 myfree(thedll->NEXT);
				   }
				   myfree(thedll);
				   return (restraint)NULL;
				 }
	default:     { evaluate_level(YELLOW,82);
				 }
  } /* switch */
return (restraint)NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leal -0x3(%r15), %eax
cmpl $0x1, %eax
ja 0xc3c0
callq 0xc258
movq %rax, %rbx
cmpl $0x5, %r15d
ja 0xc481
movl %r15d, %eax
leaq 0x315c(%rip), %rcx      # 0xf530
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rax
movq (%r14), %r14
testq %r14, %r14
jne 0xc3dd
movq 0x8(%rax), %rbx
jmp 0xc48e
testq %r14, %r14
je 0xc48c
movq %r14, %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xc3f1
jmp 0xc48e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xc48e
cmpq $0x0, 0x8(%r14)
je 0xc48c
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc3a0
movq %rax, %rbx
cmpl %ebp, 0x14(%rbx)
je 0xc48e
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xc429
jmp 0xc48c
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc3a0
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0xc48e
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc3a0
movq (%rax), %rbx
testq %rbx, %rbx
je 0xc477
movq 0x8(%rbx), %rdi
callq 0xc09f
movq %rbx, %rax
jmp 0xc461
movq %rax, %rdi
callq 0xc09f
jmp 0xc48c
pushq $0x1
popq %rdi
pushq $0x52
popq %rsi
callq 0xb0f8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markpeerdeman[P]mbemm/src/general/tril.c
// Function: fillTRIL
void fillTRIL(element theElement, FILE *fp)
{ char theKeyword[80];
  while (1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_ELEMENTS")) return;
    theElement=(element)element_dll(theElement,APPEND,0);
    theElement->type =  TRIL;
    theElement->label = atoi(theKeyword); 
    read_keyword(fp,theKeyword); theElement->p1 = atoi(theKeyword);
    read_keyword(fp,theKeyword); theElement->p2 = atoi(theKeyword);
    read_keyword(fp,theKeyword); theElement->p3 = atoi(theKeyword);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movq %rsp, %r14
leaq 0x30ae(%rip), %r15      # 0xf568
pushq $0xd
popq %r12
pushq $0x3
popq %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1140
testl %eax, %eax
je 0xc54a
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xad45
movq %rax, %r13
movl $0x2, 0x10(%rax)
movq %r14, %rdi
callq 0x1170
movl %eax, 0x14(%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
callq 0x1170
movl %eax, 0x18(%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
callq 0x1170
movl %eax, 0x1c(%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5361
movq %r14, %rdi
callq 0x1170
movl %eax, 0x20(%r13)
jmp 0xc4c1
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/rrdclient.c
// Function: cleanup
static void
cleanup(int signal)
{
    fprintf(stderr, "caught signal %d, cleaning up\n", signal);
    if (plugin) {
        rrd_close(plugin);
    }
    exit(1);
}

// Assembly:
pushq %rax
movl %edi, %edx
movq 0x7a5d(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x3b19(%rip), %rsi      # 0x50be
xorl %eax, %eax
callq 0x11e0
movq 0x7bdd(%rip), %rdi      # 0x9190
testq %rdi, %rdi
je 0x15bd
callq 0x1be3
pushq $0x1
popq %rdi
callq 0x12a0
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/librrd.c
// Function: rrd_open
RRD_PLUGIN     *
rrd_open(char *name, rrd_domain_t domain, char *path)
{
    assert(name);
    assert(path);

    RRD_PLUGIN     *plugin = malloc(sizeof(RRD_PLUGIN));
    if (!plugin) {
        return NULL;
    }
    plugin->name = name;
    plugin->path = path;
    plugin->domain = domain;
    /*
     * mark all slots for data sources as free
     */
    for (int i = 0; i < RRD_MAX_SOURCES; i++) {
        plugin->sources[i] = (RRD_SOURCE *) NULL;
    }
    plugin->n = 0;
    plugin->buf_size = 0;
    plugin->buf = NULL;
    plugin->meta = NULL;

    if (initialise(plugin) != 0) {
        invalidate(plugin);
        free(plugin);
        return NULL;
    }
    plugin->file = open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
    if (plugin->file == -1) {
        invalidate(plugin);
        free(plugin);
        return NULL;
    }
    if (write_exact(plugin->file, plugin->buf, plugin->buf_size) != 0) {
        invalidate(plugin);
        free(plugin);
        return NULL;
    }
    return plugin;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16e9
movq %rdx, %r14
testq %rdx, %rdx
je 0x1708
movl %esi, %ebp
movq %rdi, %r15
movl $0xb8, %edi
callq 0x1230
testq %rax, %rax
je 0x16a1
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0xa0(%rax)
pushq $0x2
popq %rax
cmpq $0x12, %rax
je 0x166c
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x165c
andl $0x0, 0xa4(%rbx)
andq $0x0, 0xa8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movq %rbx, %rdi
callq 0x1727
testl %eax, %eax
je 0x16b1
movq %rbx, %rdi
callq 0x1b2d
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x42
popq %rsi
movq %r14, %rdi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x1270
movl %eax, 0xb0(%rbx)
cmpl $-0x1, %eax
je 0x1691
movq 0x98(%rbx), %rsi
movq 0xa8(%rbx), %rdx
movl %eax, %edi
callq 0x1b85
testl %eax, %eax
jne 0x1691
jmp 0x16a3
leaq 0x3a10(%rip), %rdi      # 0x5100
leaq 0x3a0e(%rip), %rsi      # 0x5105
leaq 0x3a10(%rip), %rcx      # 0x510e
movl $0x13e, %edx            # imm = 0x13E
callq 0x1180
leaq 0x3a32(%rip), %rdi      # 0x5141
leaq 0x39ef(%rip), %rsi      # 0x5105
leaq 0x39f1(%rip), %rcx      # 0x510e
movl $0x13f, %edx            # imm = 0x13F
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/librrd.c
// Function: invalidate
static void
invalidate(RRD_PLUGIN * plugin)
{
    assert(plugin);

    free(plugin->buf);
    plugin->buf = NULL;
    plugin->buf_size = 0;
    json_value_free(plugin->meta);
    plugin->meta = NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1b68
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
callq 0x1030
andq $0x0, 0x98(%rbx)
andq $0x0, 0xa8(%rbx)
movq 0x90(%rbx), %rdi
callq 0x29e6
andq $0x0, 0x90(%rbx)
popq %rbx
retq
leaq 0x35d7(%rip), %rdi      # 0x5146
leaq 0x358f(%rip), %rsi      # 0x5105
leaq 0x379e(%rip), %rcx      # 0x531b
pushq $0x6d
popq %rdx
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/librrd.c
// Function: write_exact
static int
write_exact(int fd, const void *data, size_t size)
{
    size_t          offset = 0;
    ssize_t         len;
    while (offset < size) {
        len = write(fd, (const char *)data + offset, size - offset);
        if ((len == -1) && (errno == EINTR))
            continue;
        if (len <= 0)
            return -1;
        offset += len;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %ebx, %ebx
movq %r14, %r12
subq %rbx, %r12
jbe 0x1bdf
leaq (%r15,%rbx), %r13
movl %ebp, %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0x10e0
cmpq $-0x1, %rax
jne 0x1bc5
callq 0x1050
cmpl $0x4, (%rax)
je 0x1ba6
jmp 0x1bcd
addq %rax, %rbx
testq %rax, %rax
jg 0x1b9a
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x1bd0
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/librrd.c
// Function: rrd_close
int
rrd_close(RRD_PLUGIN * plugin)
{
    assert(plugin);
    int             rc;


    rc = close(plugin->file);
    if (rc == 0)
        rc = unlink(plugin->path);
    invalidate(plugin);
    free(plugin);
    return (rc == 0 ? RRD_OK : RRD_FILE_ERROR);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c2e
movq %rdi, %rbx
movl 0xb0(%rdi), %edi
callq 0x11a0
testl %eax, %eax
je 0x1c02
pushq $0x3
popq %rbp
jmp 0x1c15
movq 0x8(%rbx), %rdi
callq 0x1060
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,2), %ebp
movq %rbx, %rdi
callq 0x1b2d
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3511(%rip), %rdi      # 0x5146
leaq 0x34c9(%rip), %rsi      # 0x5105
leaq 0x350a(%rip), %rcx      # 0x514d
movl $0x16d, %edx            # imm = 0x16D
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/librrd.c
// Function: rrd_add_src
int
rrd_add_src(RRD_PLUGIN * plugin, RRD_SOURCE * source)
{
    assert(plugin);
    assert(source);

    /*
     * find free slot
     */
    size_t          i;
    for (i = 0; i < RRD_MAX_SOURCES; i++) {
        if (plugin->sources[i] == NULL)
            break;
    }
    if (i >= RRD_MAX_SOURCES) {
        return RRD_TOO_MANY_SOURCES;
    }
    plugin->sources[i] = source;
    plugin->n++;
    invalidate(plugin);

    return RRD_OK;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1c83
testq %rsi, %rsi
je 0x1ca2
pushq $0x2
popq %rcx
pushq $0x1
popq %rax
cmpq $0x12, %rcx
je 0x1c81
cmpq $0x0, (%rdi,%rcx,8)
je 0x1c70
incq %rcx
jmp 0x1c5e
movq %rsi, (%rdi,%rcx,8)
incl 0xa4(%rdi)
callq 0x1b2d
xorl %eax, %eax
popq %rcx
retq
leaq 0x34bc(%rip), %rdi      # 0x5146
leaq 0x3474(%rip), %rsi      # 0x5105
leaq 0x34d1(%rip), %rcx      # 0x5169
movl $0x17f, %edx            # imm = 0x17F
callq 0x1180
leaq 0x34ec(%rip), %rdi      # 0x5195
leaq 0x3455(%rip), %rsi      # 0x5105
leaq 0x34b2(%rip), %rcx      # 0x5169
movl $0x180, %edx            # imm = 0x180
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/librrd.c
// Function: rrd_del_src
int
rrd_del_src(RRD_PLUGIN * plugin, RRD_SOURCE * source)
{
    assert(source);
    size_t          i;
    /*
     * find slot with source
     */
    for (i = 0; i < RRD_MAX_SOURCES; i++) {
        if (plugin->sources[i] == source)
            break;
    }
    if (i >= RRD_MAX_SOURCES) {
        return RRD_NO_SUCH_SOURCE;
    }
    plugin->sources[i] = NULL;
    plugin->n--;
    invalidate(plugin);

    return RRD_OK;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1cf2
pushq $0x2
popq %rcx
pushq $0x2
popq %rax
cmpq $0x12, %rcx
je 0x1cf0
cmpq %rsi, (%rdi,%rcx,8)
je 0x1cde
incq %rcx
jmp 0x1ccd
andq $0x0, (%rdi,%rcx,8)
decl 0xa4(%rdi)
callq 0x1b2d
xorl %eax, %eax
popq %rcx
retq
leaq 0x349c(%rip), %rdi      # 0x5195
leaq 0x3405(%rip), %rsi      # 0x5105
leaq 0x3495(%rip), %rcx      # 0x519c
movl $0x19a, %edx            # imm = 0x19A
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_file
JSON_Value * json_parse_file(const char *filename) {
    char *file_contents = read_file(filename);
    JSON_Value *output_value = NULL;
    if (file_contents == NULL) {
        return NULL;
    }
    output_value = json_parse_string(file_contents);
    parson_free(file_contents);
    return output_value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1ea8
testq %rax, %rax
je 0x1e9e
movq %rax, %rbx
movq %rax, %rdi
callq 0x1f50
movq %rax, %r14
movq %rbx, %rdi
callq *0x72df(%rip)           # 0x9178
movq %r14, %rax
jmp 0x1ea0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: read_file
static char * read_file(const char * filename) {
    FILE *fp = fopen(filename, "r");
    size_t file_size;
    long pos;
    char *file_contents;
    if (!fp) {
        return NULL;
    }
    fseek(fp, 0L, SEEK_END);
    pos = ftell(fp);
    if (pos < 0) {
        fclose(fp);
        return NULL;
    }
    file_size = pos;
    rewind(fp);
    file_contents = (char*)parson_malloc(sizeof(char) * (file_size + 1));
    if (!file_contents) {
        fclose(fp);
        return NULL;
    }
    if (fread(file_contents, file_size, 1, fp) < 1) {
        if (ferror(fp)) {
            fclose(fp);
            parson_free(file_contents);
            return NULL;
        }
    }
    fclose(fp);
    file_contents[file_size] = '\0';
    return file_contents;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x3631(%rip), %rsi      # 0x54e5
callq 0x1280
testq %rax, %rax
je 0x1f25
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1240
movq %rbx, %rdi
callq 0x1200
testq %rax, %rax
js 0x1f1d
movq %rax, %r15
movq %rbx, %rdi
callq 0x1140
leaq 0x1(%r15), %rdi
callq *0x7290(%rip)           # 0x9180
testq %rax, %rax
je 0x1f1d
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x10b0
testq %rax, %rax
je 0x1f31
movq %rbx, %rdi
callq 0x10f0
movb $0x0, (%r14,%r15)
jmp 0x1f28
movq %rbx, %rdi
callq 0x10f0
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1090
testl %eax, %eax
je 0x1f0e
movq %rbx, %rdi
callq 0x10f0
movq %r14, %rdi
callq *0x722a(%rip)           # 0x9178
jmp 0x1f25
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_string
JSON_Value * json_parse_string(const char *string) {
    if (string == NULL) {
        return NULL;
    }
    if (string[0] == '\xEF' && string[1] == '\xBB' && string[2] == '\xBF') {
        string = string + 3; /* Support for UTF-8 BOM */
    }
    return parse_value((const char**)&string, 0);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x1f7f
cmpb $-0x11, (%rdi)
jne 0x1f73
cmpb $-0x45, 0x1(%rdi)
jne 0x1f73
cmpb $-0x41, 0x2(%rdi)
jne 0x1f73
addq $0x3, %rdi
movq %rdi, (%rsp)
movq %rsp, %rdi
xorl %esi, %esi
callq 0x201d
jmp 0x1f81
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_file_with_comments
JSON_Value * json_parse_file_with_comments(const char *filename) {
    char *file_contents = read_file(filename);
    JSON_Value *output_value = NULL;
    if (file_contents == NULL) {
        return NULL;
    }
    output_value = json_parse_string_with_comments(file_contents);
    parson_free(file_contents);
    return output_value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1ea8
testq %rax, %rax
je 0x1fad
movq %rax, %rbx
movq %rax, %rdi
callq 0x1fb7
movq %rax, %r14
movq %rbx, %rdi
callq *0x71d0(%rip)           # 0x9178
movq %r14, %rax
jmp 0x1faf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_string_with_comments
JSON_Value * json_parse_string_with_comments(const char *string) {
    JSON_Value *result = NULL;
    char *string_mutable_copy = NULL, *string_mutable_copy_ptr = NULL;
    string_mutable_copy = parson_strdup(string);
    if (string_mutable_copy == NULL) {
        return NULL;
    }
    remove_comments(string_mutable_copy, "/*", "*/");
    remove_comments(string_mutable_copy, "//", "\n");
    string_mutable_copy_ptr = string_mutable_copy;
    result = parse_value((const char**)&string_mutable_copy_ptr, 0);
    parson_free(string_mutable_copy);
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x24b3
testq %rax, %rax
je 0x200f
movq %rax, %rbx
leaq 0x34d9(%rip), %rsi      # 0x54a8
leaq 0x34d5(%rip), %rdx      # 0x54ab
movq %rax, %rdi
callq 0x24c8
leaq 0x34c9(%rip), %rsi      # 0x54ae
leaq 0x3103(%rip), %rdx      # 0x50ef
movq %rbx, %rdi
callq 0x24c8
movq %rsp, %rdi
movq %rbx, (%rdi)
xorl %esi, %esi
callq 0x201d
movq %rax, %r14
movq %rbx, %rdi
callq *0x716b(%rip)           # 0x9178
jmp 0x2012
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: remove_comments
static void remove_comments(char *string, const char *start_token, const char *end_token) {
    int in_string = 0, escaped = 0;
    size_t i;
    char *ptr = NULL, current_char;
    size_t start_token_len = strlen(start_token);
    size_t end_token_len = strlen(end_token);
    if (start_token_len == 0 || end_token_len == 0) {
        return;
    }
    while ((current_char = *string) != '\0') {
        if (current_char == '\\' && !escaped) {
            escaped = 1;
            string++;
            continue;
        } else if (current_char == '\"' && !escaped) {
            in_string = !in_string;
        } else if (!in_string && strncmp(string, start_token, start_token_len) == 0) {
            for(i = 0; i < start_token_len; i++) {
                string[i] = ' ';
            }
            string = string + start_token_len;
            ptr = strstr(string, end_token);
            if (!ptr) {
                return;
            }
            for (i = 0; i < (ptr - string) + end_token_len; i++) {
                string[i] = ' ';
            }
            string = ptr + end_token_len - 1;
        }
        escaped = 0;
        string++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rdi
callq 0x1110
movq %rax, %rbx
movq %r15, (%rsp)
movq %r15, %rdi
callq 0x1110
movq %rax, %r12
testq %rbx, %rbx
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
je 0x2515
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
pushq $0x1
popq %rsi
movq %r13, %rbp
xorl %eax, %eax
movq %rbx, %r15
movb (%rbp), %cl
testb %cl, %cl
je 0x2506
cmpb $0x5c, %cl
setne %dl
orb %al, %dl
testb $0x1, %dl
jne 0x2540
incq %rbp
incq %r15
movb $0x1, %al
jmp 0x2522
cmpb $0x22, %cl
setne %cl
orb %cl, %al
testb $0x1, %al
je 0x2554
testl %edi, %edi
je 0x2565
movl %esi, %edi
jmp 0x255d
xorl %eax, %eax
testl %edi, %edi
sete %al
movl %eax, %edi
incq %rbp
movq %rbp, %r13
jmp 0x251d
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1080
xorl %edi, %edi
testl %eax, %eax
je 0x257e
pushq $0x1
popq %rsi
jmp 0x255d
xorl %eax, %eax
cmpq %rax, %rbx
je 0x258f
movb $0x20, (%rbp,%rax)
incq %rax
jmp 0x2580
addq %rbx, %rbp
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0x12b0
xorl %edi, %edi
testq %rax, %rax
pushq $0x1
popq %rsi
je 0x2506
leaq (%r12,%rax), %rcx
subq %r13, %rcx
cmpq %r15, %rcx
je 0x25c3
movb $0x20, (%r13,%r15)
incq %r15
jmp 0x25b3
leaq (%rax,%r12), %rbp
decq %rbp
jmp 0x255d
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_object_nget_value
static JSON_Value * json_object_nget_value(const JSON_Object *object, const char *name, size_t n) {
    size_t i, name_length;
    for (i = 0; i < json_object_get_count(object); i++) {
        name_length = strlen(object->names[i]);
        if (name_length != n) {
            continue;
        }
        if (strncmp(object->names[i], name, n) == 0) {
            return object->values[i];
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %ebx, %ebx
xorl %ebp, %ebp
testq %r15, %r15
je 0x2626
movq 0x18(%r15), %rax
jmp 0x2628
xorl %eax, %eax
cmpq %rax, %rbp
jae 0x2661
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %r13
movq %r13, %rdi
callq 0x1110
cmpq %r14, %rax
jne 0x2654
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1080
testl %eax, %eax
je 0x2659
incq %rbp
jmp 0x261b
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_object_dotget_value
JSON_Value * json_object_dotget_value(const JSON_Object *object, const char *name) {
    const char *dot_position = strchr(name, '.');
    if (!dot_position) {
        return json_object_get_value(object, name);
    }
    object = json_value_get_object(json_object_nget_value(object, name, dot_position - name));
    return json_object_dotget_value(object, dot_position + 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
pushq $0x2e
popq %rbx
movq %r12, %rdi
movl %ebx, %esi
callq 0x1120
testq %rax, %rax
je 0x27aa
movq %rax, %r14
movq %rax, %rdx
subq %r12, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2603
testq %rax, %rax
je 0x279f
cmpl $0x4, 0x8(%rax)
jne 0x279f
movq 0x10(%rax), %r15
jmp 0x27a2
xorl %r15d, %r15d
incq %r14
movq %r14, %r12
jmp 0x276b
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x25cc
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_free
void json_value_free(JSON_Value *value) {
    switch (json_value_get_type(value)) {
        case JSONObject:
            json_object_free(value->value.object);
            break;
        case JSONString:
            parson_free(value->value.string);
            break;
        case JSONArray:
            json_array_free(value->value.array);
            break;
        default:
            break;
    }
    parson_free(value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2a79
movl 0x8(%rbx), %eax
cmpl $0x2, %eax
je 0x2a5e
cmpl $0x5, %eax
je 0x2a39
cmpl $0x4, %eax
jne 0x2a79
movq 0x10(%rbx), %r14
xorl %r15d, %r15d
movq 0x6761(%rip), %rax      # 0x9178
movq 0x8(%r14), %rdi
cmpq 0x18(%r14), %r15
jae 0x2a64
movq (%rdi,%r15,8), %rdi
callq *%rax
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x29e6
incq %r15
jmp 0x2a10
movq 0x10(%rbx), %r14
xorl %r15d, %r15d
cmpq 0x10(%r14), %r15
jae 0x2a58
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x29e6
incq %r15
jmp 0x2a40
movq 0x8(%r14), %rdi
jmp 0x2a6a
movq 0x10(%rbx), %rdi
jmp 0x2a73
callq *%rax
movq 0x10(%r14), %rdi
callq *0x6708(%rip)           # 0x9178
movq %r14, %rdi
callq *0x66ff(%rip)           # 0x9178
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x66f1(%rip)           # 0x9178
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_object
JSON_Value * json_value_init_object(void) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONObject;
    new_value->value.object = json_object_init(new_value);
    if (!new_value->value.object) {
        parson_free(new_value);
        return NULL;
    }
    return new_value;
}

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq *0x66ef(%rip)           # 0x9180
testq %rax, %rax
je 0x2ad4
movq %rax, %rbx
andq $0x0, (%rax)
movl $0x4, 0x8(%rax)
pushq $0x28
popq %rdi
callq *0x66d3(%rip)           # 0x9180
testq %rax, %rax
je 0x2ac6
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %rax, 0x10(%rbx)
jmp 0x2ad6
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq *0x66a4(%rip)           # 0x9178
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_array
JSON_Value * json_value_init_array(void) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONArray;
    new_value->value.array = json_array_init(new_value);
    if (!new_value->value.array) {
        parson_free(new_value);
        return NULL;
    }
    return new_value;
}

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq *0x669b(%rip)           # 0x9180
testq %rax, %rax
je 0x2b29
movq %rax, %rbx
andq $0x0, (%rax)
movl $0x5, 0x8(%rax)
pushq $0x20
popq %rdi
callq *0x667f(%rip)           # 0x9180
testq %rax, %rax
je 0x2b1b
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq %rax, 0x10(%rbx)
jmp 0x2b2b
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq *0x664f(%rip)           # 0x9178
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_string
JSON_Value * json_value_init_string(const char *string) {
    char *copy = NULL;
    JSON_Value *value;
    size_t string_len = 0;
    if (string == NULL) {
        return NULL;
    }
    string_len = strlen(string);
    if (!is_valid_utf8(string, string_len)) {
        return NULL;
    }
    copy = parson_strndup(string, string_len);
    if (copy == NULL) {
        return NULL;
    }
    value = json_value_init_string_no_copy(copy);
    if (value == NULL) {
        parson_free(copy);
    }
    return value;
}

// Assembly:
testq %rdi, %rdi
je 0x2d00
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1110
movq %rax, %rsi
movq %rax, %rcx
addq %rbx, %rcx
xorl %eax, %eax
pushq $0x1
popq %rdx
pushq $0x2
popq %rdi
pushq $0x3
popq %r8
pushq $0x4
popq %r9
movq %rbx, %r10
cmpq %rcx, %r10
jae 0x2d03
movzbl (%r10), %r11d
cmpl $0xf4, %r11d
ja 0x2d2b
movl %r11d, %ebp
andb $-0x2, %bpl
cmpb $-0x40, %bpl
je 0x2d2b
movl %r11d, %ebp
andl $-0x40, %ebp
cmpl $0x80, %ebp
je 0x2d2b
movq %rdx, %r14
testb %r11b, %r11b
jns 0x2cf8
movl %r11d, %ebp
andl $-0x20, %ebp
cmpl $0xc0, %ebp
jne 0x2be0
movb 0x1(%r10), %r14b
andb $-0x40, %r14b
negb %r14b
jno 0x2d2b
andl $0x1f, %r11d
shll $0x6, %r11d
xorl %r12d, %r12d
movq %rdi, %r14
jmp 0x2cb3
movl %r11d, %r14d
andl $-0x10, %r14d
cmpl $0xe0, %r14d
jne 0x2c35
movzbl 0x1(%r10), %r14d
movl %r14d, %r15d
andl $-0x40, %r15d
cmpl $0x80, %r15d
jne 0x2d2b
movb 0x2(%r10), %r15b
andb $-0x40, %r15b
negb %r15b
jno 0x2d2b
andl $0xf, %r11d
shll $0xc, %r11d
andl $0x3f, %r14d
shll $0x6, %r14d
orl %r14d, %r11d
xorl %r12d, %r12d
movq %r8, %r14
jmp 0x2cb3
movl %r11d, %r14d
andl $-0x8, %r14d
cmpl $0xf0, %r14d
jne 0x2d2b
movzbl 0x1(%r10), %r14d
movl %r14d, %r15d
andl $-0x40, %r15d
cmpl $0x80, %r15d
jne 0x2d2b
movzbl 0x2(%r10), %r15d
movl %r15d, %r12d
andl $-0x40, %r12d
cmpl $0x80, %r12d
jne 0x2d2b
movb 0x3(%r10), %r12b
andb $-0x40, %r12b
negb %r12b
jno 0x2d2b
andl $0x7, %r11d
shll $0xc, %r11d
andl $0x3f, %r14d
shll $0x6, %r14d
orl %r11d, %r14d
andl $0x3f, %r15d
orl %r14d, %r15d
shll $0x6, %r15d
movb $0x1, %r12b
movq %r9, %r14
movl %r15d, %r11d
cmpl $0x80, %r11d
jb 0x2d2b
cmpl $0x7ff, %r11d           # imm = 0x7FF
ja 0x2ccf
cmpl $0xc0, %ebp
je 0x2ce8
jmp 0x2d2b
cmpl $0xffff, %r11d          # imm = 0xFFFF
ja 0x2cdf
testb %r12b, %r12b
je 0x2ce8
jmp 0x2d2b
cmpl $0x10ffff, %r11d        # imm = 0x10FFFF
ja 0x2d2b
andl $0x1ff800, %r11d        # imm = 0x1FF800
cmpl $0xd800, %r11d          # imm = 0xD800
je 0x2d2b
addq %r14, %r10
jmp 0x2b65
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x2d34
testq %rax, %rax
je 0x2d29
movq %rax, %rbx
movq %rax, %rdi
callq 0x2d6e
testq %rax, %rax
jne 0x2d2b
movq %rbx, %rdi
callq *0x644f(%rip)           # 0x9178
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: parson_strndup
static char * parson_strndup(const char *string, size_t n) {
    char *output_string = (char*)parson_malloc(n + 1);
    if (!output_string) {
        return NULL;
    }
    output_string[n] = '\0';
    strncpy(output_string, string, n);
    return output_string;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq *0x6438(%rip)           # 0x9180
testq %rax, %rax
je 0x2d66
movb $0x0, (%rax,%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_string_no_copy
static JSON_Value * json_value_init_string_no_copy(char *string) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONString;
    new_value->value.string = string;
    return new_value;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq *0x6405(%rip)           # 0x9180
testq %rax, %rax
je 0x2d8f
andq $0x0, (%rax)
movl $0x2, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_number
JSON_Value * json_value_init_number(double number) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONNumber;
    new_value->value.number = number;
    return new_value;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq *0x63e0(%rip)           # 0x9180
testq %rax, %rax
je 0x2dba
andq $0x0, (%rax)
movl $0x3, 0x8(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
popq %rcx
retq