LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/elements.c
// Function: newelement
element newelement( void )
{ element e;
  if ( (e=(element)mymalloc(sizeof(elementtype))) == (element)NULL )
    evaluate_level(RED,70);
  e->PREV=(element)NULL; e->NEXT=(element)NULL; e->label=0;
  e->type=NONE;
  e->p1= -1; e->p2= -1; e->p3= -1;
  return e;
}

// Assembly:
pushq %rax
movl $0xc0, %edi
callq 0x17440
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x14504
movl $0x2, %edi
movl $0x46, %esi
callq 0x15200
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
movq (%rsp), %rax
movl $0x13, 0x10(%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: newimatrix
intmatrix newimatrix(int rows,int cols)
{   intmatrix m;
	static int i;

	if ( (m=(intmatrix)mymalloc(sizeof(intmatrixtype))) == (intmatrix)NULL )
	  evaluate_level(RED,21);

	m->rows = rows;
	m->cols = cols;

	if ( (m->matrix = (int **)mymalloc((unsigned int)(m->rows) * (int)sizeof(int *))) 
		== (int **)NULL)
	   evaluate_level(RED,22);
	else { for (i = 0; i < m->rows; i++)
			{ if((m->matrix[i] = (int *)mymalloc((unsigned int)(m->cols) * (int)sizeof(int))) == (int *)NULL)
				{ evaluate_level(RED,22);
				 break;
				}
			}
		 }
	m->allocated=ALLOCATED;
	allocated_matrices++;
	return m;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0x18, %edi
callq 0x17440
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x148f0
movl $0x2, %edi
movl $0x15, %esi
callq 0x15200
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1493a
movl $0x2, %edi
movl $0x16, %esi
callq 0x15200
jmp 0x149a7
movl $0x0, 0x9f54(%rip)      # 0x1e898
movl 0x9f4e(%rip), %eax      # 0x1e898
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x149a5
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x9f21(%rip), %rdx      # 0x1e898
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x14992
movl $0x2, %edi
movl $0x16, %esi
callq 0x15200
jmp 0x149a5
jmp 0x14994
movl 0x9efe(%rip), %eax      # 0x1e898
addl $0x1, %eax
movl %eax, 0x9ef5(%rip)      # 0x1e898
jmp 0x14944
jmp 0x149a7
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
leaq 0x9a2e(%rip), %rax      # 0x1e3e8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9a22(%rip), %rax      # 0x1e3e8
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: newlimatrix
lintmatrix newlimatrix(int rows,int cols)
{   lintmatrix m;
        static int i;

        if ( (m=(lintmatrix)mymalloc(sizeof(lintmatrixtype))) == (lintmatrix)NULL )
          evaluate_level(RED,21);

        m->rows = rows;
        m->cols = cols;

        if ( (m->matrix = (long int **)mymalloc((unsigned int)(m->rows) * (int)sizeof(long int *)))
                == (long int **)NULL)
           evaluate_level(RED,22);
        else { for (i = 0; i < m->rows; i++)
                        { if((m->matrix[i] = (long int *)mymalloc((unsigned int)(m->cols) * (int)sizeof(long int))) == (long int *)NULL)
                                { evaluate_level(RED,22);
                                 break;
                                }
                        }
                 }
        m->allocated=ALLOCATED;
        allocated_matrices++;
        return m;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0x18, %edi
callq 0x17440
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x14a10
movl $0x2, %edi
movl $0x15, %esi
callq 0x15200
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x14a5a
movl $0x2, %edi
movl $0x16, %esi
callq 0x15200
jmp 0x14ac7
movl $0x0, 0x9e38(%rip)      # 0x1e89c
movl 0x9e32(%rip), %eax      # 0x1e89c
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x14ac5
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x9e05(%rip), %rdx      # 0x1e89c
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x14ab2
movl $0x2, %edi
movl $0x16, %esi
callq 0x15200
jmp 0x14ac5
jmp 0x14ab4
movl 0x9de2(%rip), %eax      # 0x1e89c
addl $0x1, %eax
movl %eax, 0x9dd9(%rip)      # 0x1e89c
jmp 0x14a64
jmp 0x14ac7
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
leaq 0x990e(%rip), %rax      # 0x1e3e8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9902(%rip), %rax      # 0x1e3e8
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: newivector
intvector newivector(int rows )
{ intvector v;
  if ( (v=(intvector)mymalloc(sizeof(intvectortype))) == (intvector)NULL )
	evaluate_level(RED,23);
  v->rows = rows;
  if ( (v->data=(int *)mymalloc((unsigned int)((int)sizeof(int)*(rows+1)))) == (int *)NULL )
	evaluate_level(RED,24);
  allocated_vectors++;
  return v;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x10, %edi
callq 0x17440
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x14b2c
movl $0x2, %edi
movl $0x17, %esi
callq 0x15200
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x14b68
movl $0x2, %edi
movl $0x18, %esi
callq 0x15200
leaq 0x9881(%rip), %rax      # 0x1e3f0
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9875(%rip), %rax      # 0x1e3f0
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: delimatrix
void delimatrix(intmatrix m)
{	static int rowcnt;

	if (m->allocated!=ALLOCATED) printf("delmatrix(): matrix not allocated.\n");
	for (rowcnt = 0; rowcnt<(m->rows); rowcnt++)
	{ myfree(m->matrix[rowcnt]);
	}
	myfree(m->matrix);
	myfree(m);
	freed_matrices++;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x1, 0x10(%rax)
je 0x14bad
leaq 0x5976(%rip), %rdi      # 0x1a51c
movb $0x0, %al
callq 0x1070
movl $0x0, 0x9ce9(%rip)      # 0x1e8a0
movl 0x9ce3(%rip), %eax      # 0x1e8a0
movq (%rsp), %rcx
cmpl (%rcx), %eax
jge 0x14bee
movq (%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x9ccc(%rip), %rcx      # 0x1e8a0
movq (%rax,%rcx,8), %rdi
callq 0x174a0
movl 0x9cbd(%rip), %eax      # 0x1e8a0
addl $0x1, %eax
movl %eax, 0x9cb4(%rip)      # 0x1e8a0
jmp 0x14bb7
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x174a0
movq (%rsp), %rdi
callq 0x174a0
leaq 0x97e1(%rip), %rax      # 0x1e3ec
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x97d5(%rip), %rax      # 0x1e3ec
movl %ecx, (%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/imatrices.c
// Function: dellimatrix
void dellimatrix(lintmatrix m)
{       static int rowcnt;

        if (m->allocated!=ALLOCATED) printf("delmatrix(): matrix not allocated.\n");
        for (rowcnt = 0; rowcnt<(m->rows); rowcnt++)
        { myfree(m->matrix[rowcnt]);
        }
        myfree(m->matrix);
        myfree(m);
        freed_matrices++;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x1, 0x10(%rax)
je 0x14c3d
leaq 0x58e6(%rip), %rdi      # 0x1a51c
movb $0x0, %al
callq 0x1070
movl $0x0, 0x9c5d(%rip)      # 0x1e8a4
movl 0x9c57(%rip), %eax      # 0x1e8a4
movq (%rsp), %rcx
cmpl (%rcx), %eax
jge 0x14c7e
movq (%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x9c40(%rip), %rcx      # 0x1e8a4
movq (%rax,%rcx,8), %rdi
callq 0x174a0
movl 0x9c31(%rip), %eax      # 0x1e8a4
addl $0x1, %eax
movl %eax, 0x9c28(%rip)      # 0x1e8a4
jmp 0x14c47
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x174a0
movq (%rsp), %rdi
callq 0x174a0
leaq 0x9751(%rip), %rax      # 0x1e3ec
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9745(%rip), %rax      # 0x1e3ec
movl %ecx, (%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: newmatrix
matrix newmatrix(int rows,int cols)
{   matrix m;
	static int i;

	if ( (m=(matrix)mymalloc(sizeof(matrixtype))) == (matrix)NULL )
	  evaluate_level(RED,21);

	m->rows = rows;
	m->cols = cols;

	if ( (m->matrix = (double **)mymalloc((unsigned int)(m->rows) * (int)sizeof(double *))) 
		== (double **)NULL)
	   evaluate_level(RED,22);
	else { for (i = 0; i < m->rows; i++)
			{ if((m->matrix[i] = (double *)mymalloc((unsigned int)(m->cols) * (int)sizeof(double))) == (double *)NULL)
				{ evaluate_level(RED,22);
				 break;
				}
			}
		 }
	/* fillmatrix(m,ZEROFILL); */
	m->allocated=ALLOCATED;
	allocated_matrices++;
	return m;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0x18, %edi
callq 0x17440
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x15450
movl $0x2, %edi
movl $0x15, %esi
callq 0x15200
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1549a
movl $0x2, %edi
movl $0x16, %esi
callq 0x15200
jmp 0x15507
movl $0x0, 0x9414(%rip)      # 0x1e8b8
movl 0x940e(%rip), %eax      # 0x1e8b8
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x15505
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x93e1(%rip), %rdx      # 0x1e8b8
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x154f2
movl $0x2, %edi
movl $0x16, %esi
callq 0x15200
jmp 0x15505
jmp 0x154f4
movl 0x93be(%rip), %eax      # 0x1e8b8
addl $0x1, %eax
movl %eax, 0x93b5(%rip)      # 0x1e8b8
jmp 0x154a4
jmp 0x15507
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
leaq 0x8ece(%rip), %rax      # 0x1e3e8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x8ec2(%rip), %rax      # 0x1e3e8
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: newhypermatrix
hypermatrix newhypermatrix(int rows, int cols, int dimension )
{ hypermatrix hm;
  int i;
  if ( ( hm=(hypermatrix)mymalloc(sizeof(hypermatrixtype)) )==NULL )
	evaluate_level(RED,25);
  hm->dimension=dimension;
  if ( ( hm->data=(matrix *)mymalloc((unsigned int)((int)sizeof(matrix)*(dimension+1))) )==NULL )
	evaluate_level(RED,26);
  for (i=0; i<=(hm->dimension); i++) 
	  hm->data[i]=(matrix)newmatrix(rows,cols);
	return hm;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl $0x10, %edi
callq 0x17440
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x15574
movl $0x2, %edi
movl $0x19, %esi
callq 0x15200
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x155b0
movl $0x2, %edi
movl $0x1a, %esi
callq 0x15200
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x155f4
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x15420
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x155b8
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: newvector
vector newvector(int rows )
{ vector v;
  if ( (v=(vector)mymalloc(sizeof(vectortype))) == (vector)NULL )
	evaluate_level(RED,23);
  v->rows = rows;
  if ( (v->data=(double *)mymalloc((unsigned int)((int)sizeof(double)*(rows+1)))) == (double *)NULL )
	evaluate_level(RED,24);
  allocated_vectors++;
  return v;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x10, %edi
callq 0x17440
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x1562c
movl $0x2, %edi
movl $0x17, %esi
callq 0x15200
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x17440
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x15668
movl $0x2, %edi
movl $0x18, %esi
callq 0x15200
leaq 0x8d81(%rip), %rax      # 0x1e3f0
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x8d75(%rip), %rax      # 0x1e3f0
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: delhypermatrix
void delhypermatrix(hypermatrix hm )
{ int i;
  /* printf("deleting hypermatrix...\n"); */
  for (i=0; i<=(hm->dimension); i++) 
	  delmatrix(hm->data[i]);
  myfree( hm->data ); 
  myfree( hm );
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15762
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x15690
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15731
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x174a0
movq 0x10(%rsp), %rdi
callq 0x174a0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: fillmatrix
void fillmatrix(matrix m, int method )
{ int i, j;
  switch(method)
  { case ZEROFILL:  for (i=1; i<=m->rows; i++) 
					  for(j=1; j<=m->cols; j++) M(m,i,j)=0.0; break;
	case ONEFILL:   for (i=1; i<=m->rows; i++) 
					  for(j=1; j<=m->cols; j++) M(m,i,j)=1.0; break;
	case DELTAFILL: for (i=1; i<=m->rows; i++) 
					  for(j=1; j<=m->cols; j++) 
						M(m,i,j)=(i==j)?1.0:0.0; break;
    default:        break;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x18(%rsp)
testl %eax, %eax
je 0x157f8
jmp 0x157d7
movl -0x18(%rsp), %eax
subl $0x1, %eax
je 0x1586d
jmp 0x157e6
movl -0x18(%rsp), %eax
subl $0x2, %eax
je 0x158e7
jmp 0x15992
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15868
movl $0x1, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x15859
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x15815
jmp 0x1585b
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x15800
jmp 0x15994
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x158e2
movl $0x1, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x158d3
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0x3747(%rip), %xmm0     # 0x19008
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1588a
jmp 0x158d5
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x15875
jmp 0x15994
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15990
movl $0x1, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x1597e
movl -0x10(%rsp), %eax
movl -0x14(%rsp), %ecx
movsd 0x36e2(%rip), %xmm0     # 0x19008
xorps %xmm1, %xmm1
movsd %xmm1, -0x28(%rsp)
cmpl %ecx, %eax
movsd %xmm0, -0x20(%rsp)
je 0x15945
movsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x20(%rsp)
movsd -0x20(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x15908
jmp 0x15980
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x158ef
jmp 0x15994
jmp 0x15994
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: fillhypermatrix
void fillhypermatrix( hypermatrix hm, int method )
{ int i;
  switch(method)
  { case ZEROFILL: for (i=1; i<=hm->dimension; i++)
					   fillmatrix(hm->data[i],ZEROFILL); break;
    case ONEFILL:  for (i=1; i<=hm->dimension; i++)
					 fillmatrix(hm->data[i],ONEFILL); break;
    case DELTAFILL:for (i=1; i<=hm->dimension; i++)
					 fillmatrix(hm->data[i],DELTAFILL); break;
	default: break;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x159d8
jmp 0x159bb
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x15a18
jmp 0x159c6
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x15a58
jmp 0x15a98
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15a13
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x157c0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x159e0
jmp 0x15a9a
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15a56
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
callq 0x157c0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x15a20
jmp 0x15a9a
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15a96
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x2, %esi
callq 0x157c0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x15a60
jmp 0x15a9a
jmp 0x15a9a
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: fillvector
void fillvector( vector v, int method )
{ int i;
  switch(method)
  { case ZEROFILL:  for (i=1; i<=v->rows; i++)
		    V(v,i)=0.0;
		    break;
	case ONEFILL:   for (i=1; i<=v->rows; i++)
		    V(v,i)=1.0;
		            break;
    default:        break;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x14(%rsp)
testl %eax, %eax
je 0x15ac5
jmp 0x15ab7
movl -0x14(%rsp), %eax
subl $0x1, %eax
je 0x15b04
jmp 0x15b48
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15b02
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x15acd
jmp 0x15b4a
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15b46
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0x34d4(%rip), %xmm0     # 0x19008
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x15b0c
jmp 0x15b4a
jmp 0x15b4a
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matmul
matrix matmul( matrix a, matrix b, matrix c )
/* matmul multiplies: A = B . C, returning A */
{ int c_count, b_count; int runner;
  fillmatrix(a,ZEROFILL);
  for (c_count=1; c_count<=c->cols; c_count++)
	for (b_count=1; b_count<=b->rows; b_count++)
      for (runner=1; runner<=b->cols; runner++)
	M(a,b_count,c_count) = M(a,b_count,c_count) +
	M(b,b_count,runner)*M(c,runner,c_count);
  return a;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x157c0
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x15dd0
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15dbe
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x15dac
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x15cea
jmp 0x15dae
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x15cd1
jmp 0x15dc0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15cb7
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: scalematgeneral
matrix  scalematgeneral( matrix a, double b, matrix c )
/* scalematgeneral scales: A = b . C, returning A */
{ int c_count, r_count;
  for (c_count=1; c_count<=c->cols; c_count++)
	for (r_count=1; r_count<=c->rows; r_count++)
	  M(a,r_count,c_count)=b * M(c,r_count,c_count);
  return a;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x1, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x15e90
movl $0x1, -0x20(%rsp)
movl -0x20(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x15e7e
movsd -0x10(%rsp), %xmm0
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15e12
jmp 0x15e80
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x15df8
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: scalemat3x3
void scalemat3x3( matrix a, double b )
{ M(a,1,1) *= b;
  M(a,1,2) *= b;
  M(a,1,3) *= b;
  M(a,2,1) *= b;
  M(a,2,2) *= b;
  M(a,2,3) *= b;
  M(a,3,1) *= b;
  M(a,3,2) *= b;
  M(a,3,3) *= b;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
mulsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
mulsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
mulsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matsumgeneral
matrix matsumgeneral( matrix a, matrix b, matrix c )
/* matsum sums: A = B + C, returning A */
{ int c_count, b_count;
  for (c_count=1; c_count<=c->cols; c_count++)
	for (b_count=1; b_count<=b->rows; b_count++)
	  M(a,b_count,c_count)=M(b,b_count,c_count)+M(c,b_count,c_count);
  return a;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x1, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x16086
movl $0x1, -0x20(%rsp)
movl -0x20(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x16074
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15fe1
jmp 0x16076
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x15fc7
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matsum3x3
void matsum3x3( matrix a, matrix b )
{ M(a,1,1) += M(b,1,1);
  M(a,1,2) += M(b,1,2);
  M(a,1,3) += M(b,1,3);
  M(a,2,1) += M(b,2,1);
  M(a,2,2) += M(b,2,2);
  M(a,2,3) += M(b,2,3);
  M(a,3,1) += M(b,3,1);
  M(a,3,2) += M(b,3,2);
  M(a,3,3) += M(b,3,3);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: transpose3x3
void transpose3x3( matrix m )
{ /* transposes a matrix: */
  double tmp;
  tmp=M(m,1,2); M(m,1,2)=M(m,2,1); M(m,2,1)=tmp;
  tmp=M(m,1,3); M(m,1,3)=M(m,3,1); M(m,3,1)=tmp;
  tmp=M(m,2,3); M(m,2,3)=M(m,3,2); M(m,3,2)=tmp;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd %xmm0, 0x8(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, (%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %edi
callq 0x15600
movq %rax, 0x8(%rsp)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x4(%rsp), %eax
jg 0x163f6
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl (%rsp), %eax
jg 0x163c8
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1635c
movsd 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1633d
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x16448
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x163fe
movq 0x8(%rsp), %rdi
callq 0x15780
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x4eb6(%rip), %rdi      # 0x1b3a0
movb $0x0, %al
callq 0x1070
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x16573
movl $0x1, (%rsp)
movl (%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x16558
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl (%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x4e6d(%rip), %rdi      # 0x1b3b3
movb $0x1, %al
callq 0x1070
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1650d
leaq 0x2c5e(%rip), %rdi      # 0x191bd
movb $0x0, %al
callq 0x1070
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x164f9
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x4e11(%rip), %rdi      # 0x1b3bb
movb $0x0, %al
callq 0x1070
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x16603
movl 0x4(%rsp), %esi
leaq 0x4e02(%rip), %rdi      # 0x1b3d3
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2ac2(%rip), %rsi      # 0x190b3
callq 0x164d0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x165b9
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x4da5(%rip), %rdi      # 0x1b3df
movb $0x0, %al
callq 0x1070
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x16689
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x4d7d(%rip), %rdi      # 0x1b3f2
movb $0x1, %al
callq 0x1070
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x16649
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/matrices.c
// Function: matcopy3x3
void matcopy3x3( matrix source, matrix dest )
{ M(dest,1,1)=M(source,1,1);
  M(dest,1,2)=M(source,1,2);
  M(dest,1,3)=M(source,1,3);
  M(dest,2,1)=M(source,2,1);
  M(dest,2,2)=M(source,2,2);
  M(dest,2,3)=M(source,2,3);
  M(dest,3,1)=M(source,3,1);
  M(dest,3,2)=M(source,3,2);
  M(dest,3,3)=M(source,3,3);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movsd %xmm0, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl 0x34(%rsp), %edi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x16ed0
movl $0x0, 0xc(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x34(%rsp), %ecx
addl 0x30(%rsp), %ecx
cmpl %ecx, %eax
jge 0x17190
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1717e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x17173
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x34(%rsp), %ecx
addl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1711e
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x17180
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x170ee
movl $0x1, 0xc(%rsp)
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0x17248
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x17236
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x1722b
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x34(%rsp), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x34(%rsp), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0x34(%rsp), %ecx
subl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x171ca
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x17238
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x171a3
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0xc(%rsp)
movl %esi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x17304
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x172a5
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1738f
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x172f6
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rsp), %ecx
movq -0x20(%rsp), %rdx
movq 0x8(%rdx), %rdx
movslq -0x14(%rsp), %rsi
addl (%rdx,%rsi,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1738f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1738f
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jl 0x17332
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1738f
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x17386
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rsp), %ecx
subl 0x755e(%rip), %ecx      # 0x1e8c0
movq -0x20(%rsp), %rdx
movq 0x8(%rdx), %rdx
movslq -0x14(%rsp), %rsi
addl (%rdx,%rsi,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1738f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x17469
movq 0x6ba0(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
leaq 0x3fba(%rip), %rsi      # 0x1b41c
movb $0x0, %al
callq 0x10d0
movq 0x10(%rsp), %rdi
callq 0x10f0
movq %rax, 0x8(%rsp)
movl 0x744a(%rip), %eax      # 0x1e8c8
addl $0x1, %eax
movl %eax, 0x7441(%rip)      # 0x1e8c8
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x174cc
movq 0x6b45(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
leaq 0x3f7f(%rip), %rsi      # 0x1b43c
movb $0x0, %al
callq 0x10d0
movq (%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x1030
movl 0x73ed(%rip), %eax      # 0x1e8c8
addl $-0x1, %eax
movl %eax, 0x73e4(%rip)      # 0x1e8c8
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x88, %edi
callq 0x17440
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x17564
movl $0x2, %edi
movl $0xa, %esi
callq 0x15200
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xb, 0x14(%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x48, %edi
callq 0x17440
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x17864
movl $0x2, %edi
movl $0x50, %esi
callq 0x15200
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8f80
leaq 0x20(%rsp), %rdi
leaq 0x3c21(%rip), %rsi      # 0x1b4e0
callq 0x10c0
cmpl $0x0, %eax
jne 0x178ce
jmp 0x17a32
leaq 0x20(%rsp), %rdi
leaq 0x3c14(%rip), %rsi      # 0x1b4ee
callq 0x10c0
cmpl $0x0, %eax
jne 0x178e9
jmp 0x17a32
leaq 0x20(%rsp), %rdi
leaq 0x2687(%rip), %rsi      # 0x19f7c
callq 0x10c0
cmpl $0x0, %eax
jne 0x17904
jmp 0x17a32
movq 0x80(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x80(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x17a40
movq %rax, 0x80(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x80(%rsp), %rax
movl %ecx, 0x10(%rax)
leaq 0x20(%rsp), %rdi
callq 0x1130
movl %eax, %ecx
movq 0x80(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8f80
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movsd %xmm0, 0x10(%rsp)
movq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8f80
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movsd %xmm0, 0x8(%rsp)
movq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8f80
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x80(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x80(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movsd (%rsp), %xmm0
movq 0x80(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movsd 0x10(%rsp), %xmm0
movq 0x80(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x80(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movsd (%rsp), %xmm0
movq 0x80(%rsp), %rax
movsd %xmm0, 0x40(%rax)
jmp 0x178a4
addq $0x88, %rsp
retq
nopw (%rax,%rax)