LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: skip_C_nodes
void skip_C_nodes(FILE *fp)
{ static char theKeyword[80];
  while (1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_CNODES")) return;
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x15230(%rip), %rsi     # 0x1e520
callq 0x8f80
leaq 0x15224(%rip), %rdi     # 0x1e520
leaq 0x10c24(%rip), %rsi     # 0x19f27
callq 0x10c0
cmpl $0x0, %eax
jne 0x930f
popq %rax
retq
jmp 0x92e5
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: read_elements
void read_elements(FILE *fp, mesh theMesh)
/* This function calls the function fillTRIL() when the keyword 'elements'
 * is encountered. When other elements are implemented, the switch has to be
 * made in this little function.
 */
{ static char theKeyword[80];
  read_keyword(fp,theKeyword);

  /* make a 'switch' here when other element types are implemented: */
  if (!strcmp(theKeyword,"TRIL")) 
  { /* evaluate_level(GREEN,55); */
    fillTRIL(theMesh->mesh_e,fp); 
    return; 
  }
  else evaluate_level(YELLOW,58);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x15036(%rip), %rsi     # 0x1e5c0
callq 0x8f80
leaq 0x1502a(%rip), %rdi     # 0x1e5c0
leaq 0x10995(%rip), %rsi     # 0x19f32
callq 0x10c0
cmpl $0x0, %eax
jne 0x95bc
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x17ca0
jmp 0x95cb
movl $0x1, %edi
movl $0x3a, %esi
callq 0x15200
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: read_material
void read_material(FILE *fp)
/* This function reads the material card */
{ static char theKeyword[80];
  /* evaluate_level(GREEN,62); */
  read_keyword(fp,theKeyword); modulus_of_elasticity = strtod(theKeyword,NULL);
  read_keyword(fp,theKeyword); poissons_ratio = strtod(theKeyword,NULL);

}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x14fb0(%rip), %rsi     # 0x1e610
callq 0x8f80
leaq 0x14fa4(%rip), %rdi     # 0x1e610
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
leaq 0x14d5c(%rip), %rax     # 0x1e3d8
movsd %xmm0, (%rax)
movq (%rsp), %rdi
leaq 0x14f85(%rip), %rsi     # 0x1e610
callq 0x8f80
leaq 0x14f79(%rip), %rdi     # 0x1e610
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
leaq 0x14d39(%rip), %rax     # 0x1e3e0
movsd %xmm0, (%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: write_universal_req
void write_universal_req(void)
/* This function sets the global switch for writing universal files */
{ WRITE_UNIVERSAL=YES;
  WRITE_SPECIAL=NO;
  WRITE_OBJ=NO;
  /*evaluate_level(GREEN,66);*/
}

// Assembly:
leaq 0x14d45(%rip), %rax     # 0x1e3fc
movl $0x1, (%rax)
leaq 0x14d34(%rip), %rax     # 0x1e3f8
movl $0x0, (%rax)
leaq 0x14d2f(%rip), %rax     # 0x1e400
movl $0x0, (%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: write_special_req
void write_special_req(void)
/* This function sets the global switch for writing the special format */
{ WRITE_SPECIAL=YES;
  WRITE_UNIVERSAL=NO;
  WRITE_OBJ=NO;
  /* evaluate_level(GREEN,67); */
}

// Assembly:
leaq 0x14d11(%rip), %rax     # 0x1e3f8
movl $0x1, (%rax)
leaq 0x14d08(%rip), %rax     # 0x1e3fc
movl $0x0, (%rax)
leaq 0x14cff(%rip), %rax     # 0x1e400
movl $0x0, (%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: write_obj_req
void write_obj_req(void)
/* This function sets the global switch for writing the .OBJ format */
{ WRITE_SPECIAL=NO;
  WRITE_UNIVERSAL=NO;
  WRITE_OBJ=YES;
  evaluate_level(GREEN,65);
}

// Assembly:
pushq %rax
leaq 0x14ce0(%rip), %rax     # 0x1e3f8
movl $0x0, (%rax)
leaq 0x14cd7(%rip), %rax     # 0x1e3fc
movl $0x0, (%rax)
leaq 0x14cce(%rip), %rax     # 0x1e400
movl $0x1, (%rax)
xorl %edi, %edi
movl $0x41, %esi
callq 0x15200
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: parse_contact
void parse_contact(char *name, cmesh theCMesh)
{ FILE *fp;
  static char theKeyword[80];
  point p;
  fprintf(stderr,"parsing contact...\n");
  if ( (fp=fopen(name,"r"))==(FILE *)NULL ) evaluate_level(RED,50);
  evaluate_level(GREEN,51);
  /* do something when a keyword is encountered: */
  while (!feof(fp))
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"CNODES")) fill_C_points(fp,theCMesh); 
  }
  /* calculate the cylinder normals: */
  p = (point)point_dll(theCMesh->merged_mesh->mesh_p,START,0);
  while (p!=(point)NULL)
  { if (p->type==CNODE) 
    { /* calculate_cyl_normal(p); */
      fprintf(stderr,"node %d, x: %f y %f z %f, has normals %f %f %f\n",p->label,
		p->x, p->y, p->z, p->n1, p->n2, p->n3);  
    }
    p=p->NEXT;
  }
  fprintf(stderr,"Contact parsed\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x14573(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x104f1(%rip), %rsi     # 0x19f80
movb $0x0, %al
callq 0x10d0
movq 0x20(%rsp), %rdi
leaq 0x11180(%rip), %rsi     # 0x1ac22
callq 0x1110
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x9ac1
movl $0x2, %edi
movl $0x32, %esi
callq 0x15200
xorl %edi, %edi
movl $0x33, %esi
callq 0x15200
movq 0x10(%rsp), %rdi
callq 0x10e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9ae5
jmp 0x9b1f
movq 0x10(%rsp), %rdi
leaq 0x14bbf(%rip), %rsi     # 0x1e6b0
callq 0x8f80
leaq 0x14bb3(%rip), %rdi     # 0x1e6b0
leaq 0x10427(%rip), %rsi     # 0x19f2b
callq 0x10c0
cmpl $0x0, %eax
jne 0x9b1d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9320
jmp 0x9acd
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x9bb7
movq 0x8(%rsp), %rax
cmpl $0xf, 0x14(%rax)
jne 0x9ba7
movq 0x144a6(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x28(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x30(%rax), %xmm2
movq 0x8(%rsp), %rax
movsd 0x68(%rax), %xmm3
movq 0x8(%rsp), %rax
movsd 0x70(%rax), %xmm4
movq 0x8(%rsp), %rax
movsd 0x78(%rax), %xmm5
leaq 0x103f4(%rip), %rsi     # 0x19f94
movb $0x6, %al
callq 0x10d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x9b38
movq 0x1443a(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x103fc(%rip), %rsi     # 0x19fc4
movb $0x0, %al
callq 0x10d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: parse_solution
void parse_solution(char *name, vector thesolutionvector)
{ FILE *fp;
  static char theKeyword[80];
  if ( (fp=fopen(name,"r"))==(FILE *)NULL ) evaluate_level(RED,50);
  evaluate_level(GREEN,51);
  /* do something when a keyword is encountered: */
  while (!feof(fp))
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"SOLUTION")) fill_solutionvector(fp,thesolutionvector);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x11028(%rip), %rsi     # 0x1ac22
callq 0x1110
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x9c18
movl $0x2, %edi
movl $0x32, %esi
callq 0x15200
xorl %edi, %edi
movl $0x33, %esi
callq 0x15200
movq (%rsp), %rdi
callq 0x10e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9c3b
jmp 0x9c73
movq (%rsp), %rdi
leaq 0x14aba(%rip), %rsi     # 0x1e700
callq 0x8f80
leaq 0x14aae(%rip), %rdi     # 0x1e700
leaq 0x102c5(%rip), %rsi     # 0x19f1e
callq 0x10c0
cmpl $0x0, %eax
jne 0x9c71
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x91e0
jmp 0x9c24
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: tijdbalkjec
void tijdbalkjec(int deKnoop)
{ /* deze functie tekent een nifty tijdbalkje om te kunnen zien of de
   * de software nog ergens mee bezig is...
   */
   float fraction;
   int pos, pos2;

   if (deKnoop==0) /* teken het tijdbalkje */
   { /* lengte van de lijn is 65 */
   fprintf(stderr,"\n* Building system of equations...\n");
fprintf(stderr,"=================================================================\n");
	 ccurpos = 0;
   }
   else if (deKnoop==-1) /* maak het tijdbalkje af */
		{
fprintf(stderr,"\n=================================================================\n\n");
		}
		else /* teken het percentage */
		{ fraction = (float)((float)deKnoop/(float)cn_nodes);
		  pos = (int)(fraction*(float)65.0);
		  if (pos>ccurpos) {
			pos2 = 0;
			while (pos2<pos)
			  { fprintf(stderr,">");
				pos2++;
              }
			  fprintf(stderr,"\r");
			}
            ccurpos=pos;
		}
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0xa16e
movq 0x13ec2(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x100a8(%rip), %rsi     # 0x1a1e8
movb $0x0, %al
callq 0x10d0
movq 0x13eaa(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0xfe89(%rip), %rsi      # 0x19fe1
movb $0x0, %al
callq 0x10d0
movl $0x0, 0x145f7(%rip)     # 0x1e760
jmp 0xa227
cmpl $-0x1, 0x14(%rsp)
jne 0xa192
movq 0x13e7c(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0xeeb4(%rip), %rsi      # 0x1903a
movb $0x0, %al
callq 0x10d0
jmp 0xa225
cvtsi2ssl 0x14(%rsp), %xmm0
cvtsi2ssl 0x145b0(%rip), %xmm1 # 0x1e750
divss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0xee52(%rip), %xmm0     # 0x19004
mulss 0x10(%rsp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14596(%rip), %eax     # 0x1e760
jle 0xa21b
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xa203
movq 0x13e13(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0xee90(%rip), %rsi      # 0x1907f
movb $0x0, %al
callq 0x10d0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xa1d4
movq 0x13dee(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0xee6d(%rip), %rsi      # 0x19081
movb $0x0, %al
callq 0x10d0
movl 0xc(%rsp), %eax
movl %eax, 0x1453b(%rip)     # 0x1e760
jmp 0xa227
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: init_integration_matricesc
void init_integration_matricesc(void)
{ int i;
  ctemp = (matrix)newmatrix(3,3);
  /* matrices for intermediate gauss integration values: */
  ctf=(matrix *)mymalloc(8*sizeof(matrix));
  if (ctf==(matrix *)NULL) evaluate_level(RED,108);
  cuf=(matrix *)mymalloc(8*sizeof(matrix));
  if (cuf==(matrix *)NULL) evaluate_level(RED,108);
  for (i=0; i<=7; i++) 
  { ctf[i]=(matrix)newmatrix(3,3);
    cuf[i]=(matrix)newmatrix(3,3);
  }
}

// Assembly:
pushq %rax
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, 0x14524(%rip)     # 0x1e768
movl $0x40, %edi
callq 0x17440
movq %rax, 0x1451b(%rip)     # 0x1e770
cmpq $0x0, 0x14513(%rip)     # 0x1e770
jne 0xa26e
movl $0x2, %edi
movl $0x6c, %esi
callq 0x15200
movl $0x40, %edi
callq 0x17440
movq %rax, 0x144f9(%rip)     # 0x1e778
cmpq $0x0, 0x144f1(%rip)     # 0x1e778
jne 0xa298
movl $0x2, %edi
movl $0x6c, %esi
callq 0x15200
movl $0x0, 0x4(%rsp)
cmpl $0x7, 0x4(%rsp)
jg 0xa2f2
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, %rdx
movq 0x144b3(%rip), %rax     # 0x1e770
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, %rdx
movq 0x1449c(%rip), %rax     # 0x1e778
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa2a0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: init_linearc
void init_linearc(void)
{ 
  evaluate_level(GREEN,100);
  if (READ_SOLUTION==NO)
  { main_E=(matrix)newmatrix(3*cn_nodes,3*cn_nodes);
  }
  else main_E=(matrix)newmatrix(3,3);
  fillmatrix(main_E,ZEROFILL); 
  main_f=(vector)newvector(3*cn_nodes); fillvector(main_f,ZEROFILL);
  init_integration_matricesc();
  clocal=(matrix)newmatrix(3,3);
}

// Assembly:
pushq %rax
xorl %edi, %edi
movl $0x64, %esi
callq 0x15200
leaq 0x140f0(%rip), %rax     # 0x1e404
cmpl $0x0, (%rax)
jne 0xa33b
imull $0x3, 0x14430(%rip), %edi # 0x1e750
imull $0x3, 0x14429(%rip), %esi # 0x1e750
callq 0x15420
movq %rax, %rcx
leaq 0x140da(%rip), %rax     # 0x1e410
movq %rcx, (%rax)
jmp 0xa354
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, %rcx
leaq 0x140bf(%rip), %rax     # 0x1e410
movq %rcx, (%rax)
leaq 0x140b5(%rip), %rax     # 0x1e410
movq (%rax), %rdi
xorl %esi, %esi
callq 0x157c0
imull $0x3, 0x143e4(%rip), %edi # 0x1e750
callq 0x15600
movq %rax, %rcx
leaq 0x1409d(%rip), %rax     # 0x1e418
movq %rcx, (%rax)
leaq 0x14093(%rip), %rax     # 0x1e418
movq (%rax), %rdi
xorl %esi, %esi
callq 0x15aa0
callq 0xa230
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, 0x143d9(%rip)     # 0x1e780
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: close_linearc
void close_linearc(void)
{ int i;
  evaluate_level(GREEN,101); 
  delmatrix(ctemp);
  delmatrix(clocal);

  for (i=0; i<=7; i++) 
  { delmatrix(ctf[i]);
	delmatrix(cuf[i]);
  }
  myfree(ctf);
  myfree(cuf);
  
}

// Assembly:
pushq %rax
xorl %edi, %edi
movl $0x65, %esi
callq 0x15200
movq 0x143a4(%rip), %rdi     # 0x1e768
callq 0x15690
movq 0x143b0(%rip), %rdi     # 0x1e780
callq 0x15690
movl $0x0, 0x4(%rsp)
cmpl $0x7, 0x4(%rsp)
jg 0xa41b
movq 0x14385(%rip), %rax     # 0x1e770
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x15690
movq 0x14378(%rip), %rax     # 0x1e778
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x15690
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa3dd
movq 0x1434e(%rip), %rdi     # 0x1e770
callq 0x174a0
movq 0x1434a(%rip), %rdi     # 0x1e778
callq 0x174a0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: collocatec
void collocatec(point sourcenode,element fieldelement,
			   hypermatrix c,hypermatrix e)
{ /* IN:          see prototype
   * OUT:         nothing
   * MODIFIES:    matrices c and e
   * USES:        nothing
   * DESCRIPTION: This function collocates the sourcenode to the nodes of
   *              the element fieldelement.
   */

  /* First the normal integrations: */
   if ( (sourcenode->label!=fieldelement->p1) &&
	(sourcenode->label!=fieldelement->p2) &&
	(sourcenode->label!=fieldelement->p3) )
   {    init_normal_integrationc(sourcenode,fieldelement);
	norm_intc( fieldelement, c, e);
	return;
   } /* if */

  /* Singular integrations: */
   if ( (sourcenode->label==fieldelement->p1) ||
	(sourcenode->label==fieldelement->p2) ||
	(sourcenode->label==fieldelement->p3) )
   {    sing_int( fieldelement, c, e, sourcenode->label ); 
	return;
   } /* if */

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0xa9b3
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
je 0xa9b3
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x20(%rcx), %eax
je 0xa9b3
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xa440
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xa630
jmp 0xaa05
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0xa9e9
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
je 0xa9e9
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jne 0xaa05
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
callq 0xfab0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: contact3
void contact3(cmesh theCMesh)
{ point       sourcenode;
  hypermatrix c;
  hypermatrix e;
  hypermatrix crow;
  hypermatrix erow;
  mesh theMesh;

  theMesh=theCMesh->merged_mesh;

  printstatusc(theMesh);
  init_linearc();


if (READ_SOLUTION==NO)
{
  c=(hypermatrix)newhypermatrix(3,3,3);
  e=(hypermatrix)newhypermatrix(3,3,3);
  crow=(hypermatrix)newhypermatrix(3,3,cn_nodes);
  erow=(hypermatrix)newhypermatrix(3,3,cn_nodes);

  tijdbalkjec(0);
  sourcenode=(point)point_dll(theMesh->mesh_p,START,0);
  while (sourcenode!=(point)NULL)
  { tijdbalkjec(sourcenode->label); 
    make_rowc(sourcenode,crow,erow,c,e,theCMesh);
    make_a(sourcenode,crow,erow,theCMesh);
    plug_inc(sourcenode->label,crow); 
    sourcenode=sourcenode->NEXT;
  }

  tijdbalkjec(-1);

  delhypermatrix(c);
  delhypermatrix(e);
  delhypermatrix(crow);
  delhypermatrix(erow);
} /* if READ_SOLUTION is is NO */

  close_linearc();

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x9c80
callq 0xa300
leaq 0x1099a(%rip), %rax     # 0x1e404
cmpl $0x0, (%rax)
jne 0xdb88
movl $0x3, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x15540
movq %rax, 0x20(%rsp)
movl $0x3, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x15540
movq %rax, 0x18(%rsp)
movl 0x10cb1(%rip), %edx     # 0x1e750
movl $0x3, %esi
movl %esi, %edi
callq 0x15540
movq %rax, 0x10(%rsp)
movl 0x10c9a(%rip), %edx     # 0x1e750
movl $0x3, %esi
movl %esi, %edi
callq 0x15540
movq %rax, 0x8(%rsp)
xorl %edi, %edi
callq 0xa120
movq (%rsp), %rax
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xdb56
movq 0x28(%rsp), %rax
movl 0x10(%rax), %edi
callq 0xa120
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x30(%rsp), %r9
callq 0xaa10
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0xc6d0
movq 0x28(%rsp), %rax
movl 0x10(%rax), %edi
movq 0x10(%rsp), %rsi
callq 0xb370
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0xdae3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xa120
movq 0x20(%rsp), %rdi
callq 0x15720
movq 0x18(%rsp), %rdi
callq 0x15720
movq 0x10(%rsp), %rdi
callq 0x15720
movq 0x8(%rsp), %rdi
callq 0x15720
callq 0xa3b0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: init_singular
void init_singular(void)
{ /* IN:          nothing
   * OUT:         nothing
   * MODIFIES:    sinA1, sinA2, sinA3, cosA1, cosA2, cosA3, normal,
   *              n1, n2, n3
   * USES:        theElement
   * DESCRIPTION: Initialisation function for all globals of this module.
   */


  /* calculate the cosines and sines of the element corners: */
   sinA1 = sin( theElement->alpha1 );
   cosA1 = cos( theElement->alpha1 );

   sinA2 = sin( theElement->alpha2 );
   cosA2 = cos( theElement->alpha2 );

   sinA3 = sin( theElement->alpha3 );
   cosA3 = cos( theElement->alpha3 );

  /* copy the node coordinates in the arrays n1, n2 and n3: */
   n1[1]=theElement->p1x; n1[2]=theElement->p1y; n1[3]=theElement->p1z;
   n2[1]=theElement->p2x; n2[2]=theElement->p2y; n2[3]=theElement->p2z;
   n3[1]=theElement->p3x; n3[2]=theElement->p3y; n3[3]=theElement->p3z;

   normal[1] = theElement->nx;
   normal[2] = theElement->ny;
   normal[3] = theElement->nz;

}

// Assembly:
pushq %rax
movq 0x10be8(%rip), %rax     # 0x1e790
movsd 0x70(%rax), %xmm0
callq 0x1120
movsd %xmm0, 0x10bde(%rip)    # 0x1e798
movq 0x10bcf(%rip), %rax     # 0x1e790
movsd 0x70(%rax), %xmm0
callq 0x10a0
movsd %xmm0, 0x10bcd(%rip)    # 0x1e7a0
movq 0x10bb6(%rip), %rax     # 0x1e790
movsd 0x78(%rax), %xmm0
callq 0x1120
movsd %xmm0, 0x10bbc(%rip)    # 0x1e7a8
movq 0x10b9d(%rip), %rax     # 0x1e790
movsd 0x78(%rax), %xmm0
callq 0x10a0
movsd %xmm0, 0x10bab(%rip)    # 0x1e7b0
movq 0x10b84(%rip), %rax     # 0x1e790
movsd 0x80(%rax), %xmm0
callq 0x1120
movsd %xmm0, 0x10b97(%rip)    # 0x1e7b8
movq 0x10b68(%rip), %rax     # 0x1e790
movsd 0x80(%rax), %xmm0
callq 0x10a0
movsd %xmm0, 0x10b83(%rip)    # 0x1e7c0
movq 0x10b4c(%rip), %rax     # 0x1e790
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x10b87(%rip)    # 0x1e7d8
movq 0x10b38(%rip), %rax     # 0x1e790
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x10b7b(%rip)    # 0x1e7e0
movq 0x10b24(%rip), %rax     # 0x1e790
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x10b6f(%rip)    # 0x1e7e8
movq 0x10b10(%rip), %rax     # 0x1e790
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x10b6b(%rip)    # 0x1e7f8
movq 0x10afc(%rip), %rax     # 0x1e790
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x10b5f(%rip)    # 0x1e800
movq 0x10ae8(%rip), %rax     # 0x1e790
movsd 0x50(%rax), %xmm0
movsd %xmm0, 0x10b53(%rip)    # 0x1e808
movq 0x10ad4(%rip), %rax     # 0x1e790
movsd 0x58(%rax), %xmm0
movsd %xmm0, 0x10b4f(%rip)    # 0x1e818
movq 0x10ac0(%rip), %rax     # 0x1e790
movsd 0x60(%rax), %xmm0
movsd %xmm0, 0x10b43(%rip)    # 0x1e820
movq 0x10aac(%rip), %rax     # 0x1e790
movsd 0x68(%rax), %xmm0
movsd %xmm0, 0x10b37(%rip)    # 0x1e828
movq 0x10a98(%rip), %rax     # 0x1e790
movsd 0xa0(%rax), %xmm0
movsd %xmm0, 0x10b30(%rip)    # 0x1e838
movq 0x10a81(%rip), %rax     # 0x1e790
movsd 0xa8(%rax), %xmm0
movsd %xmm0, 0x10b21(%rip)    # 0x1e840
movq 0x10a6a(%rip), %rax     # 0x1e790
movsd 0xb0(%rax), %xmm0
movsd %xmm0, 0x10b12(%rip)    # 0x1e848
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: rotate_hypermatrix
void rotate_hypermatrix(const int rotations, const hypermatrix hm)
{ /* IN:          integer from function rotate_element() and the hyper-
   *              matrix to be rotated
   * OUT:         nothing
   * MODIFIES:    the hypermatrix given in the argument
   * DESCRIPTION: this function rotates the calculated results back, so
   *              the calculated results map directly to the original
   *              element.
   */
   matrix tmp;

   /* printf("rotating hypermatrix back over %d nodes\n",rotations);*/
   if (rotations==0)
   { /* printf("rotation not necessary\n"); */
	 return;
   }
   if (rotations==1)
   { /* printf("Rotating back over one node\n"); */
	 tmp = hm->data[3];
	 hm->data[3]=hm->data[2];
	 hm->data[2]=hm->data[1];
	 hm->data[1]=tmp;
	 return;
   }
   if (rotations==2)
   { /* printf("Rotating back over two nodes\n"); */
	 tmp = hm->data[1];
	 hm->data[1]=hm->data[2];
	 hm->data[2]=hm->data[3];
	 hm->data[3]=tmp;
	 return;
   }

}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
cmpl $0x0, -0x4(%rsp)
jne 0xe1c5
jmp 0xe285
cmpl $0x1, -0x4(%rsp)
jne 0xe226
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xe285
cmpl $0x2, -0x4(%rsp)
jne 0xe285
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_v
double make_v(const vector v)
{ /* IN:          vector v which has to be filled
   * OUT:         beta
   * MODIFIES:    vector v
   * USES:        theElement
   * DESCRIPTION:
   * The vector v is calculated from the element data from theElement.
   * beta, i.e. v[1] is  returned.
   */

  /* first component: */
   V(v,1) = 1.0/tan(0.5*theElement->alpha2)
		  * 1.0/tan(0.5*theElement->alpha3);
   V(v,1) = log(V(v,1));

  /* second component: */
   V(v,2) = V(v,1)*cosA3
		  + theElement->z3/theElement->z2
		  - 1.0;
   V(v,2) = V(v,2) * theElement->z2/theElement->z1;

  /* third component: */
   V(v,3) = V(v,1)*cosA2
		  + theElement->z2/theElement->z3
		  - 1.0;
   V(v,3) = V(v,3) *theElement->z3/theElement->z1;

   return V(v,1);

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x104f0(%rip), %rax     # 0x1e790
movsd 0xb188(%rip), %xmm0     # 0x19430
mulsd 0x78(%rax), %xmm0
callq 0x1100
movaps %xmm0, %xmm1
movsd 0xad4b(%rip), %xmm0     # 0x19008
divsd %xmm1, %xmm0
movsd 0xad3f(%rip), %xmm1     # 0x19008
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x104b6(%rip), %rax     # 0x1e790
movsd 0xb14e(%rip), %xmm0     # 0x19430
mulsd 0x80(%rax), %xmm0
callq 0x1100
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
callq 0x1090
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd 0x10483(%rip), %xmm2    # 0x1e7c0
movq 0x1044c(%rip), %rax     # 0x1e790
movsd 0x98(%rax), %xmm1
movq 0x1043d(%rip), %rax     # 0x1e790
divsd 0x90(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xac9d(%rip), %xmm1     # 0x19008
subsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0x8(%rax), %xmm0
movq 0x103fe(%rip), %rax     # 0x1e790
mulsd 0x90(%rax), %xmm0
movq 0x103ef(%rip), %rax     # 0x1e790
divsd 0x88(%rax), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd 0x103e4(%rip), %xmm2    # 0x1e7b0
movq 0x103bd(%rip), %rax     # 0x1e790
movsd 0x90(%rax), %xmm1
movq 0x103ae(%rip), %rax     # 0x1e790
divsd 0x98(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xac0e(%rip), %xmm1     # 0x19008
subsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0x10(%rax), %xmm0
movq 0x1036f(%rip), %rax     # 0x1e790
mulsd 0x98(%rax), %xmm0
movq 0x10360(%rip), %rax     # 0x1e790
divsd 0x88(%rax), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scalemesh
void scalemesh(mesh theMesh)
{ element elm;
  /* scale the system to a dimensionless monster... */
  scalesystem(theMesh); 

  /* complete the element data with the values for z1, z2, z3, alpha1,
   * alpha2 and alpha3: */
   elm=(element)element_dll(theMesh->mesh_e,START,0);
   while (elm!=(element)NULL)
   { TRILcompletion(elm,theMesh->mesh_p);
     elm=(element)elm->NEXT;
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10210
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x14570
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10204
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x181d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x101da
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scalesystem
void scalesystem(mesh theMesh)
{ init_scale(theMesh);
  determineGscale(theMesh); scalegeometry(theMesh);
  determineTscale(theMesh); scaletractions(theMesh);
  determineDscale(theMesh); scaledisplacements(theMesh);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x10260
movq (%rsp), %rdi
callq 0x10670
movq (%rsp), %rdi
callq 0x10690
movq (%rsp), %rdi
callq 0x10980
movq (%rsp), %rdi
callq 0x109f0
movq (%rsp), %rdi
callq 0x107d0
movq (%rsp), %rdi
callq 0x10840
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scalegeometry
void scalegeometry(mesh theMesh)
{ point q;
  q = (point)point_dll(theMesh->mesh_p,START,0);
  while (q!=(point)NULL)
  { q->x=q->x/theMesh->G_SCALE;
    q->y=q->y/theMesh->G_SCALE;
    q->z=q->z/theMesh->G_SCALE;
    q=q->NEXT;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10721
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x30(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x8(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x30(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movq 0x8(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x30(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x106af
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: determineDscale
void determineDscale(mesh theMesh)
{ /* The D_SCALE is defined as T_SCALE*G_SCALE/EMOD... */
  if (fabs(tmax)>1.0E-13) {
    theMesh->D_SCALE=theMesh->T_SCALE*theMesh->G_SCALE/EMOD;
  }
  else {
    theMesh->D_SCALE=dmax;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd 0xe083(%rip), %xmm0     # 0x1e860
movaps 0x882c(%rip), %xmm1     # 0x19010
pand %xmm1, %xmm0
movsd 0x9a90(%rip), %xmm1     # 0x1a280
ucomisd %xmm1, %xmm0
jbe 0x10821
movq -0x8(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq -0x8(%rsp), %rax
mulsd 0x30(%rax), %xmm0
leaq 0xdbc7(%rip), %rax      # 0x1e3d8
divsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x38(%rax)
jmp 0x10833
movsd 0xe02f(%rip), %xmm0     # 0x1e858
movq -0x8(%rsp), %rax
movsd %xmm0, 0x38(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaledisplacements
void scaledisplacements(mesh theMesh)
{ restraint di; 
  di = (restraint)restraint_dll(theMesh->mesh_d,START,0);
  while (di!=(restraint)NULL)
  { di->u1=di->u1/theMesh->D_SCALE;
    di->u2=di->u2/theMesh->D_SCALE;
    di->u3=di->u3/theMesh->D_SCALE;
    di=di->NEXT;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x17a40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x108d2
movq 0x8(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x8(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq 0x8(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x10860
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaledisplacementsback
void scaledisplacementsback(mesh theMesh)
{ point q;
  q = (point)point_dll(theMesh->mesh_p,START,0);
  while (q!=(point)NULL)
  { q->dx=q->dx*theMesh->D_SCALE;
    q->dy=q->dy*theMesh->D_SCALE;
    q->dz=q->dz*theMesh->D_SCALE;
    q=q->NEXT;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10971
movq 0x8(%rsp), %rax
movsd 0x50(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x50(%rax)
movq 0x8(%rsp), %rax
movsd 0x58(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x58(%rax)
movq 0x8(%rsp), %rax
movsd 0x60(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x60(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x108ff
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: determineTscale
void determineTscale(mesh theMesh)
{ /* The T_SCALE is defined as the maximum applied displacement component times EMOD.  */
   if (fabs(dmax)>1.0E-13) {
     theMesh->T_SCALE=dmax*EMOD/theMesh->G_SCALE;
   }
   else {
     theMesh->T_SCALE=tmax;
   }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd 0xdecb(%rip), %xmm0     # 0x1e858
movaps 0x867c(%rip), %xmm1     # 0x19010
pand %xmm1, %xmm0
movsd 0x98e0(%rip), %xmm1     # 0x1a280
ucomisd %xmm1, %xmm0
jbe 0x109cf
movsd 0xdeaa(%rip), %xmm0     # 0x1e858
leaq 0xda23(%rip), %rax      # 0x1e3d8
mulsd (%rax), %xmm0
movq -0x8(%rsp), %rax
divsd 0x30(%rax), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x40(%rax)
jmp 0x109e1
movsd 0xde89(%rip), %xmm0     # 0x1e860
movq -0x8(%rsp), %rax
movsd %xmm0, 0x40(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaletractions
void scaletractions(mesh theMesh)
{ restraint tr; 
  tr = (restraint)restraint_dll(theMesh->mesh_t,START,0);
  while (tr!=(restraint)NULL)
  { tr->f1=tr->f1/theMesh->T_SCALE;
    tr->f2=tr->f2/theMesh->T_SCALE;
    tr->f3=tr->f3/theMesh->T_SCALE;
    tr=tr->NEXT;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x17a40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10a82
movq 0x8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x40(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x40(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x8(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd 0x40(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x10a10
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: scaletractionsback
void scaletractionsback(mesh theMesh)
{ point q;
  q = (point)point_dll(theMesh->mesh_p,START,0);
  while (q!=(point)NULL)
  { q->fx=q->fx*theMesh->T_SCALE;
    q->fy=q->fy*theMesh->T_SCALE;
    q->fz=q->fz*theMesh->T_SCALE;
    q=q->NEXT;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10b21
movq 0x8(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x40(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq 0x8(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x40(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x40(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x10aaf
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/scale.c
// Function: determineEscale
void determineEscale(mesh theMesh)
{ /* find the smallest distance between two nodes: */
  double mindist=1.0E6;
  double curdist;
  element e;

  e = (element)element_dll(theMesh->mesh_e,START,0);
  while (e!=(element)NULL)
  { curdist = e->z1; if (curdist<mindist) mindist=curdist;
    curdist = e->z2; if (curdist<mindist) mindist=curdist;
    curdist = e->z3; if (curdist<mindist) mindist=curdist;
	e=e->NEXT;
  }
  theMesh->E_SCALE=mindist;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd 0x930f(%rip), %xmm0     # 0x19e50
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x14570
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10c10
movq 0x8(%rsp), %rax
movsd 0x88(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10b9b
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rax
movsd 0x90(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10bcc
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rax
movsd 0x98(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10bfd
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x10b5e
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x48(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: tijdbalkje
void tijdbalkje(int deKnoop)
{ /* deze functie tekent een nifty tijdbalkje om te kunnen zien of de
   * de software nog ergens mee bezig is...
   */
   float fraction;
   int pos, pos2;

   if (deKnoop==0) /* teken het tijdbalkje */
   { /* lengte van de lijn is 65 */
   fprintf(stderr,"\n* Building system of equations...\n");
fprintf(stderr,"=================================================================\n");
	 curpos = 0;
   }
   else if (deKnoop==-1) /* maak het tijdbalkje af */
		{
fprintf(stderr,"\n=================================================================\n\n");
		}
		else /* teken het percentage */
		{ fraction = (float)((float)deKnoop/(float)n_nodes);
		  pos = (int)(fraction*(float)65.0);
		  if (pos>curpos) {
			pos2 = 0;
			while (pos2<pos)
			  { fprintf(stderr,">");
				pos2++;
              }
			  fprintf(stderr,"\r");
			}
            curpos=pos;
		}
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x1113e
movq 0xcef2(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
leaq 0x90d8(%rip), %rsi      # 0x1a1e8
movb $0x0, %al
callq 0x10d0
movq 0xceda(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
leaq 0x8eb9(%rip), %rsi      # 0x19fe1
movb $0x0, %al
callq 0x10d0
movl $0x0, 0xd73f(%rip)      # 0x1e878
jmp 0x111f7
cmpl $-0x1, 0x14(%rsp)
jne 0x11162
movq 0xceac(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
leaq 0x7ee4(%rip), %rsi      # 0x1903a
movb $0x0, %al
callq 0x10d0
jmp 0x111f5
cvtsi2ssl 0x14(%rsp), %xmm0
cvtsi2ssl 0xd6f8(%rip), %xmm1 # 0x1e868
divss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x7e82(%rip), %xmm0     # 0x19004
mulss 0x10(%rsp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0xd6de(%rip), %eax      # 0x1e878
jle 0x111eb
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x111d3
movq 0xce43(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
leaq 0x7ec0(%rip), %rsi      # 0x1907f
movb $0x0, %al
callq 0x10d0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x111a4
movq 0xce1e(%rip), %rax      # 0x1dff8
movq (%rax), %rdi
leaq 0x7e9d(%rip), %rsi      # 0x19081
movb $0x0, %al
callq 0x10d0
movl 0xc(%rsp), %eax
movl %eax, 0xd683(%rip)      # 0x1e878
jmp 0x111f7
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: init_integration_matrices
void init_integration_matrices(void)
{ int i;
  temp = (matrix)newmatrix(3,3);
  /* matrices for intermediate gauss integration values: */
  tf=(matrix *)mymalloc(8*sizeof(matrix));
  if (tf==(matrix *)NULL) evaluate_level(RED,108);
  uf=(matrix *)mymalloc(8*sizeof(matrix));
  if (uf==(matrix *)NULL) evaluate_level(RED,108);
  for (i=0; i<=7; i++) 
  { tf[i]=(matrix)newmatrix(3,3);
    uf[i]=(matrix)newmatrix(3,3);
  }
}

// Assembly:
pushq %rax
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, 0xd66c(%rip)      # 0x1e880
movl $0x40, %edi
callq 0x17440
movq %rax, 0xd663(%rip)      # 0x1e888
cmpq $0x0, 0xd65b(%rip)      # 0x1e888
jne 0x1123e
movl $0x2, %edi
movl $0x6c, %esi
callq 0x15200
movl $0x40, %edi
callq 0x17440
movq %rax, 0xd641(%rip)      # 0x1e890
cmpq $0x0, 0xd639(%rip)      # 0x1e890
jne 0x11268
movl $0x2, %edi
movl $0x6c, %esi
callq 0x15200
movl $0x0, 0x4(%rsp)
cmpl $0x7, 0x4(%rsp)
jg 0x112c2
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, %rdx
movq 0xd5fb(%rip), %rax      # 0x1e888
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, %rdx
movq 0xd5e4(%rip), %rax      # 0x1e890
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x11270
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: init_linear
void init_linear(void)
{ 
  evaluate_level(GREEN,100);
  if (READ_SOLUTION==NO)
  { main_E=(matrix)newmatrix(3*n_nodes,3*n_nodes);
  }
  else main_E=(matrix)newmatrix(3,3);
  fillmatrix(main_E,ZEROFILL); 
  main_f=(vector)newvector(3*n_nodes);
  main_u=(vector)newvector(3*n_nodes);
  init_integration_matrices();
}

// Assembly:
pushq %rax
xorl %edi, %edi
movl $0x64, %esi
callq 0x15200
leaq 0xd120(%rip), %rax      # 0x1e404
cmpl $0x0, (%rax)
jne 0x1130b
imull $0x3, 0xd578(%rip), %edi # 0x1e868
imull $0x3, 0xd571(%rip), %esi # 0x1e868
callq 0x15420
movq %rax, %rcx
leaq 0xd10a(%rip), %rax      # 0x1e410
movq %rcx, (%rax)
jmp 0x11324
movl $0x3, %esi
movl %esi, %edi
callq 0x15420
movq %rax, %rcx
leaq 0xd0ef(%rip), %rax      # 0x1e410
movq %rcx, (%rax)
leaq 0xd0e5(%rip), %rax      # 0x1e410
movq (%rax), %rdi
xorl %esi, %esi
callq 0x157c0
imull $0x3, 0xd52c(%rip), %edi # 0x1e868
callq 0x15600
movq %rax, %rcx
leaq 0xd0cd(%rip), %rax      # 0x1e418
movq %rcx, (%rax)
imull $0x3, 0xd513(%rip), %edi # 0x1e868
callq 0x15600
movq %rax, %rcx
leaq 0xd0bc(%rip), %rax      # 0x1e420
movq %rcx, (%rax)
callq 0x11200
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: close_linear
void close_linear(void)
{ int i;
  evaluate_level(GREEN,101); 
  delmatrix(temp);

  for (i=0; i<=7; i++) 
  { delmatrix(tf[i]);
	delmatrix(uf[i]);
  }
  myfree(tf);
  myfree(uf);
}

// Assembly:
pushq %rax
xorl %edi, %edi
movl $0x65, %esi
callq 0x15200
movq 0xd4fc(%rip), %rdi      # 0x1e880
callq 0x15690
movl $0x0, 0x4(%rsp)
cmpl $0x7, 0x4(%rsp)
jg 0x113cf
movq 0xd4e9(%rip), %rax      # 0x1e888
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x15690
movq 0xd4dc(%rip), %rax      # 0x1e890
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x15690
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x11391
movq 0xd4b2(%rip), %rdi      # 0x1e888
callq 0x174a0
movq 0xd4ae(%rip), %rdi      # 0x1e890
callq 0x174a0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: make_rhs_vector
void make_rhs_vector(mesh theMesh)
{ restraint r;

  fillvector(main_u,ZEROFILL);
  fillvector(main_f,ZEROFILL);

  r=(restraint)restraint_dll(theMesh->mesh_t,START,0);
  while (r!=(restraint)NULL)
  { V(main_u,r->label*3-2)=r->f1;
    V(main_u,r->label*3-1)=r->f2;
    V(main_u,r->label*3  )=r->f3;
    r=r->NEXT;
  }
  r=(restraint)restraint_dll(theMesh->mesh_d,START,0);
  while (r!=(restraint)NULL)
  { V(main_u,r->label*3-2)=r->u1;
    V(main_u,r->label*3-1)=r->u2;
    V(main_u,r->label*3  )=r->u3;
    r=r->NEXT;
  }

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0xc0b0(%rip), %rax      # 0x1e420
movq (%rax), %rdi
xorl %esi, %esi
callq 0x15aa0
leaq 0xc097(%rip), %rax      # 0x1e418
movq (%rax), %rdi
xorl %esi, %esi
callq 0x15aa0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x17a40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1244b
movq 0x8(%rsp), %rax
movsd 0x18(%rax), %xmm0
leaq 0xc061(%rip), %rax      # 0x1e420
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
imull $0x3, 0x14(%rcx), %ecx
subl $0x2, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
leaq 0xc032(%rip), %rax      # 0x1e420
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
imull $0x3, 0x14(%rcx), %ecx
subl $0x1, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movsd 0x28(%rax), %xmm0
leaq 0xc003(%rip), %rax      # 0x1e420
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
imull $0x3, 0x14(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x123a2
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x17a40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1250b
movq 0x8(%rsp), %rax
movsd 0x30(%rax), %xmm0
leaq 0xbfa1(%rip), %rax      # 0x1e420
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
imull $0x3, 0x14(%rcx), %ecx
subl $0x2, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movsd 0x38(%rax), %xmm0
leaq 0xbf72(%rip), %rax      # 0x1e420
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
imull $0x3, 0x14(%rcx), %ecx
subl $0x1, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movsd 0x40(%rax), %xmm0
leaq 0xbf43(%rip), %rax      # 0x1e420
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
imull $0x3, 0x14(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x12462
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: linear3
void linear3(mesh theMesh)
{ point       sourcenode;
  hypermatrix c;
  hypermatrix e;
  hypermatrix crow;
  hypermatrix erow;

  printstatus(theMesh);
  init_linear();

if (READ_SOLUTION==NO)
{
  c=(hypermatrix)newhypermatrix(3,3,3);
  e=(hypermatrix)newhypermatrix(3,3,3);
  crow=(hypermatrix)newhypermatrix(3,3,n_nodes);
  erow=(hypermatrix)newhypermatrix(3,3,n_nodes);

  make_rhs_vector(theMesh);

  tijdbalkje(0);
  sourcenode=(point)point_dll(theMesh->mesh_p,START,0);
  while (sourcenode!=(point)NULL)
  { tijdbalkje(sourcenode->label); 
    make_row(sourcenode,crow,erow,c,e,theMesh);
    remap(crow,erow,sourcenode,theMesh); 
    plug_in(sourcenode->label,erow);
    sourcenode=sourcenode->NEXT;
  }

  tijdbalkje(-1);
  delhypermatrix(c);
  delhypermatrix(e);
  delhypermatrix(crow);
  delhypermatrix(erow);
} /* if READ_SOLUTION == NO */

  close_linear();

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x10c60
callq 0x112d0
leaq 0xbbd5(%rip), %rax      # 0x1e404
cmpl $0x0, (%rax)
jne 0x12958
movl $0x3, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x15540
movq %rax, 0x20(%rsp)
movl $0x3, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x15540
movq %rax, 0x18(%rsp)
movl 0xc004(%rip), %edx      # 0x1e868
movl $0x3, %esi
movl %esi, %edi
callq 0x15540
movq %rax, 0x10(%rsp)
movl 0xbfed(%rip), %edx      # 0x1e868
movl $0x3, %esi
movl %esi, %edi
callq 0x15540
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x12360
xorl %edi, %edi
callq 0x110f0
movq 0x30(%rsp), %rax
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x12926
movq 0x28(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x110f0
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x30(%rsp), %r9
callq 0x11c30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x11e50
movq 0x28(%rsp), %rax
movl 0x10(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x12510
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x128b3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x110f0
movq 0x20(%rsp), %rdi
callq 0x15720
movq 0x18(%rsp), %rdi
callq 0x15720
movq 0x10(%rsp), %rdi
callq 0x15720
movq 0x8(%rsp), %rdi
callq 0x15720
callq 0x11370
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)