LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/post.c
// Function: elforce2
void elforce2(element e, double *fx, double *fy, double *fz, mesh theMesh)
{ point p;
  double t1x, t1y, t1z, t2x, t2y, t2z, t3x, t3y, t3z;

        /* get the traction forces at the three nodes of the element: */
        /* NODE 1: */
        p=(point)point_dll(theMesh->mesh_p,SEARCH,e->p1);
        t1x=p->fx; t1y=p->fy; t1z=p->fz;
        /* NODE 2: */
        p=(point)point_dll(theMesh->mesh_p,SEARCH,e->p2);
        t2x=p->fx; t2y=p->fy; t2z=p->fz;
        /* NODE 3: */
        p=(point)point_dll(theMesh->mesh_p,SEARCH,e->p3);
        t3x=p->fx; t3y=p->fy; t3z=p->fz;

        *fx= 1.0/3.0*(t1x+t2x+t3x)*theMesh->G_SCALE;
        *fy= 1.0/3.0*(t1y+t2y+t3y)*theMesh->G_SCALE;
        *fz= 1.0/3.0*(t1z+t2z+t3z)*theMesh->G_SCALE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%r8), %rdi
movl 0x18(%r13), %edx
movl $0x2, %esi
callq 0xcf07
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq (%r14), %rdi
movl 0x1c(%r13), %edx
movl $0x2, %esi
callq 0xcf07
movq (%r14), %rdi
movl 0x20(%r13), %edx
movsd 0x8(%rsp), %xmm0
addsd 0x38(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x40(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x2, %esi
callq 0xcf07
movsd 0x8(%rsp), %xmm1
addsd 0x38(%rax), %xmm1
movsd 0x97d3(%rip), %xmm0     # 0xe450
mulsd %xmm0, %xmm1
mulsd 0x30(%r14), %xmm1
movapd %xmm1, %xmm3
movsd 0x10(%rsp), %xmm2
addsd 0x40(%rax), %xmm2
movsd 0x18(%rsp), %xmm1
addsd 0x48(%rax), %xmm1
movsd %xmm3, (%r12)
mulsd %xmm0, %xmm2
mulsd 0x30(%r14), %xmm2
movsd %xmm2, (%r15)
mulsd %xmm0, %xmm1
mulsd 0x30(%r14), %xmm1
movsd %xmm1, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/post.c
// Function: U_write_nodes
void U_write_nodes(const point plist)
{ point p;
  int color;
  printf("    -1\n"); 
  printf("  2411\n");
  p=(point)point_dll(plist,START,0);
  while (p!=(point)NULL)
  { color=p->type; 
	printf("%10d         1         1%10d\n",p->label,color);
  	printf("  % 1.16E  % 1.16E  % 1.16E\n",p->x,p->y,p->z); 
	p=p->NEXT;
  }
  printf("    -1\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x91fd(%rip), %rdi      # 0xeda0
callq 0x1060
leaq 0x90de(%rip), %rdi      # 0xec8d
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x5c08
movq %rax, %rbx
leaq 0x8a84(%rip), %r14      # 0xe653
leaq 0x8a9b(%rip), %r15      # 0xe671
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
movsd 0x20(%rbx), %xmm0
movsd 0x28(%rbx), %xmm1
movsd 0x30(%rbx), %xmm2
movq %r15, %rdi
movb $0x3, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x5bd6
leaq 0x9191(%rip), %rdi      # 0xeda0
popq %rbx
popq %r14
popq %r15
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/post.c
// Function: U_write_elements
void U_write_elements(const element elist)
{ element e; 
  int color = 7;
  printf("    -1\n");
  printf("  2412\n");
  e=(element)element_dll(elist,START,0);
  while(e!=(element)NULL)
  { color = e->type;
	printf("%10d%10d%10d%10d%10d%10d\n",e->label,91,1,1,color,3); 
	printf("%10d%10d%10d\n",e->p1,e->p3,e->p2);
	e=e->NEXT;
  } 
  printf("    -1\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9174(%rip), %rdi      # 0xeda0
callq 0x1060
leaq 0x905c(%rip), %rdi      # 0xec94
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb834
testq %rax, %rax
je 0x5ca3
movq %rax, %rbx
leaq 0x8a36(%rip), %r14      # 0xe68e
leaq 0x8a3b(%rip), %r15      # 0xe69a
movl 0x10(%rbx), %r9d
movl 0x14(%rbx), %esi
movl $0x3, (%rsp)
movq %r14, %rdi
movl $0x5b, %edx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %eax, %eax
callq 0x1090
movl 0x20(%rbx), %edx
movl 0x18(%rbx), %esi
movl 0x1c(%rbx), %ecx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x5c5f
leaq 0x90f6(%rip), %rdi      # 0xeda0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/post.c
// Function: U_write_displacements
void U_write_displacements(const point plist)
{ point p;
  printf("    -1\n");
  printf("  2414\n");
  printf("         1\n");
  printf(" Nodal displacements\n");
  printf("         1\n");
  printf("ElastoMath BEM results\n");
  printf("ELASTOMATH_SOLVE\n");
  printf("LOAD SET 1\n");
  printf("Analysis time was     8-May-66       14:24:27\n");
  printf("NONE\n");
  printf("         1         1         3         8         2         6\n");
  printf("       -10         0         1         1         1         0");
  printf("         0         0\n");
  printf("         2         0\n");
  printf("  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00");
  printf("  0.00000E+00\n");
  printf("  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00");
  printf("  0.00000E+00\n");

  p=(point)point_dll(plist,START,0);
  while (p!=(point)NULL)
  {	printf("%10d\n",p->label);
	printf(" % 1.5E % 1.5E % 1.5E  0.00000E+00  0.00000E+00  0.00000E+00\n",
	 (double)p->dx, (double)p->dy,
	 (double)p->dz );
    p=p->NEXT;
  }

  printf("    -1\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x90d9(%rip), %rdi      # 0xeda0
callq 0x1060
leaq 0x8fdd(%rip), %rdi      # 0xecb0
callq 0x1060
leaq 0x8fa3(%rip), %r14      # 0xec82
movq %r14, %rdi
callq 0x1060
leaq 0x8fad(%rip), %rdi      # 0xec9b
callq 0x1060
movq %r14, %rdi
callq 0x1060
leaq 0x8fd1(%rip), %rdi      # 0xecd3
callq 0x1060
leaq 0x8fdc(%rip), %rdi      # 0xecea
callq 0x1060
leaq 0x8fe1(%rip), %rdi      # 0xecfb
callq 0x1060
leaq 0x8fe0(%rip), %rdi      # 0xed06
callq 0x1060
leaq 0x9002(%rip), %rdi      # 0xed34
callq 0x1060
leaq 0x8ffb(%rip), %rdi      # 0xed39
callq 0x1060
leaq 0x8881(%rip), %rdi      # 0xe5cb
xorl %eax, %eax
callq 0x1090
leaq 0x901e(%rip), %rdi      # 0xed76
callq 0x1060
leaq 0x9027(%rip), %rdi      # 0xed8b
callq 0x1060
leaq 0x8898(%rip), %r14      # 0xe608
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
leaq 0x88bb(%rip), %r15      # 0xe63c
movq %r15, %rdi
callq 0x1060
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
movq %r15, %rdi
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x5dec
movq %rax, %rbx
leaq 0x88b5(%rip), %r14      # 0xe66b
leaq 0x88eb(%rip), %r15      # 0xe6a8
movl 0x10(%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
movsd 0x50(%rbx), %xmm0
movsd 0x58(%rbx), %xmm1
movsd 0x60(%rbx), %xmm2
movq %r15, %rdi
movb $0x3, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x5dbd
leaq 0x8fad(%rip), %rdi      # 0xeda0
popq %rbx
popq %r14
popq %r15
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/post.c
// Function: U_write_tractions
void U_write_tractions(const point plist)
{ point p;
  printf("    -1\n");
  printf("  2414\n");
  printf("         2\n");
  printf(" Nodal tractions\n");
  printf("         1\n");
  printf("ElastoMath BEM results\n");
  printf("ELASTOMATH_SOLVE\n");
  printf("LOAD SET 1\n");
  printf("Analysis time was     8-May-66       14:24:27\n");
  printf("NONE\n");
  printf("         1         1         3         8         2         6\n");
  printf("       -10         0         1         1         1         0");
  printf("         0         0\n");
  printf("         2         0\n");
  printf("  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00");
  printf("  0.00000E+00\n");
  printf("  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00  0.00000E+00");
  printf("  0.00000E+00\n");

  p=(point)point_dll(plist,START,0);
  while (p!=(point)NULL)
  { printf("%10d\n",p->label);
    printf(" % 1.5E % 1.5E % 1.5E  0.00000E+00  0.00000E+00  0.00000E+00\n",
     (double)p->fx, (double)p->fy,
     (double)p->fz );
    p=p->NEXT;
  }

  printf("    -1\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8f94(%rip), %rdi      # 0xeda0
callq 0x1060
leaq 0x8e98(%rip), %rdi      # 0xecb0
callq 0x1060
leaq 0x8e93(%rip), %rdi      # 0xecb7
callq 0x1060
leaq 0x8e92(%rip), %rdi      # 0xecc2
callq 0x1060
leaq 0x8e46(%rip), %rdi      # 0xec82
callq 0x1060
leaq 0x8e8b(%rip), %rdi      # 0xecd3
callq 0x1060
leaq 0x8e96(%rip), %rdi      # 0xecea
callq 0x1060
leaq 0x8e9b(%rip), %rdi      # 0xecfb
callq 0x1060
leaq 0x8e9a(%rip), %rdi      # 0xed06
callq 0x1060
leaq 0x8ebc(%rip), %rdi      # 0xed34
callq 0x1060
leaq 0x8eb5(%rip), %rdi      # 0xed39
callq 0x1060
leaq 0x873b(%rip), %rdi      # 0xe5cb
xorl %eax, %eax
callq 0x1090
leaq 0x8ed8(%rip), %rdi      # 0xed76
callq 0x1060
leaq 0x8ee1(%rip), %rdi      # 0xed8b
callq 0x1060
leaq 0x8752(%rip), %r14      # 0xe608
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
leaq 0x8775(%rip), %r15      # 0xe63c
movq %r15, %rdi
callq 0x1060
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
movq %r15, %rdi
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x5f32
movq %rax, %rbx
leaq 0x876f(%rip), %r14      # 0xe66b
leaq 0x87a5(%rip), %r15      # 0xe6a8
movl 0x10(%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
movsd 0x38(%rbx), %xmm0
movsd 0x40(%rbx), %xmm1
movsd 0x48(%rbx), %xmm2
movq %r15, %rdi
movb $0x3, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x5f03
leaq 0x8e67(%rip), %rdi      # 0xeda0
popq %rbx
popq %r14
popq %r15
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: fgetc_sc
int fgetc_sc(FILE *fp)
/* this function gets a character from stream fp, skipping everything between
 * the characters named 'theJohn' and 'theAnita', defined above.
 */
{ char c;
  int johns=0;
  do
  { c=(char)fgetc(fp);
	if (feof(fp)) return (int)' ';
	if (c==theJohn)  johns++;
	if (c==theAnita) johns--;
  } while( johns!=0 );
  if (c==theAnita) c=' ';
  return (int)c;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x10b0
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1110
testl %eax, %eax
jne 0x6582
shll $0x18, %ebp
xorl %eax, %eax
cmpl $0x7b000000, %ebp       # imm = 0x7B000000
sete %al
addl %eax, %r14d
xorl %eax, %eax
cmpl $0x7d000000, %ebp       # imm = 0x7D000000
sete %al
subl %eax, %r14d
jne 0x6536
movl %ebp, %ecx
sarl $0x18, %ecx
cmpl $0x7d000000, %ebp       # imm = 0x7D000000
movl $0x20, %eax
cmovnel %ecx, %eax
jmp 0x6587
movl $0x20, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: read_keyword
void read_keyword( FILE *fp, char *data)
/* This function reads a keyword string from the stream fp. The keyword is
 * returned (capitalized), terminated with a \0 string terminator. When EOF is
 * encountered, the keyword 'END' is returned.
 */
{ int ch;
  int i=0;
  /* search begin of next keyword: */
  do
  { ch=fgetc_sc(fp);
	if (feof(fp))
	{ /* evaluate_level(GREEN,52); */
	  data[0]='E'; data[1]='N'; data[2]='D'; data[3]=(char)0;
	  return;
	}
  }
  while (isspace(ch));
  /* read keyword in the datastring: */
  while ( !isspace(ch) )
  { data[i++]=(char)toupper(ch);
    if (i>79) evaluate_level(YELLOW,58);
    ch=toupper(fgetc_sc(fp));
  }
  data[i]=(char)0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
callq 0x652c
movl %eax, %ebp
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
jne 0x6618
callq 0x11c0
movq %rax, %r15
movq (%rax), %rcx
movslq %ebp, %rax
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x659a
movq (%r15), %rcx
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x6628
xorl %r12d, %r12d
movl %ebp, %edi
callq 0x1050
movb %al, (%rbx,%r12)
cmpq $0x4f, %r12
jb 0x65f2
movl $0x1, %edi
movl $0x3a, %esi
callq 0xbc50
movq %r14, %rdi
callq 0x652c
movl %eax, %edi
callq 0x1050
movl %eax, %ebp
movq (%r15), %rax
movslq %ebp, %rcx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
je 0x65d2
movl %r12d, %eax
jmp 0x662a
movw $0x4e45, (%rbx)         # imm = 0x4E45
movb $0x44, 0x2(%rbx)
movl $0x3, %eax
jmp 0x662a
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: read_points
void read_points(FILE *fp, mesh theMesh)
/* this function reads the point data into the the mesh's point dll. Data is
 * read until the keyword 'END_NODES' is encountered. Syntax errors are NOT
 * processed!
 */
{ static char theKeyword[80];
  /* evaluate_level(GREEN,54); */
  while (1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_NODES")) return;
    theMesh->mesh_p=point_dll(theMesh->mesh_p,APPEND,0);
    theMesh->mesh_p->label =  atoi(theKeyword); 
    read_keyword(fp,theKeyword); theMesh->mesh_p->x = strtod(theKeyword,NULL);
    read_keyword(fp,theKeyword); theMesh->mesh_p->y = strtod(theKeyword,NULL);
    read_keyword(fp,theKeyword); theMesh->mesh_p->z = strtod(theKeyword,NULL);
    theMesh->mesh_p->type=NODE;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x45444f4e5f444e45, %r13 # imm = 0x45444F4E5F444E45
leaq 0xee09(%rip), %rsi      # 0x15460
callq 0x658c
movq 0xedfd(%rip), %rax      # 0x15460
xorq %r13, %rax
movzwl 0xedfb(%rip), %ecx      # 0x15468
xorq $0x53, %rcx
orq %rax, %rcx
je 0x672a
leaq 0xeddf(%rip), %r15      # 0x15460
movq (%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xcf07
movq %rax, %r12
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1180
movl %eax, 0x10(%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq (%rbx), %rax
movsd %xmm0, 0x20(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq (%rbx), %rax
movsd %xmm0, 0x28(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq (%rbx), %rax
movsd %xmm0, 0x30(%rax)
movl $0xb, 0x14(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq 0xed4d(%rip), %rax      # 0x15460
xorq %r13, %rax
movzwl 0xed4b(%rip), %ecx      # 0x15468
xorq $0x53, %rcx
orq %rax, %rcx
jne 0x6681
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: skip_solutionvector
void skip_solutionvector(FILE *fp)
{ static char theKeyword[80];
  READ_SOLUTION=YES;
  while (1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_SOLUTION")) return;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xecee(%rip), %rax      # 0x15434
movl $0x1, (%rax)
leaq 0xed5d(%rip), %r14      # 0x154b0
movabsq $0x554c4f535f444e45, %r15 # imm = 0x554C4F535F444E45
movabsq $0x4e4f4954554c4f, %r12 # imm = 0x4E4F4954554C4F
movq %rbx, %rdi
movq %r14, %rsi
callq 0x658c
movq 0xed37(%rip), %rax      # 0x154b0
xorq %r15, %rax
movq 0xed32(%rip), %rcx      # 0x154b5
xorq %r12, %rcx
orq %rax, %rcx
jne 0x6767
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: fill_solutionvector
void fill_solutionvector(FILE *fp,vector thesolutionvector)
{ static char theKeyword[80];
  int i=1;
  while (1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_SOLUTION")) return;
	else 
	{ V(thesolutionvector,i++)=strtod(theKeyword,NULL);
	  read_keyword(fp,theKeyword); V(thesolutionvector,i++)=strtod(theKeyword,NULL);
	  read_keyword(fp,theKeyword); V(thesolutionvector,i++)=strtod(theKeyword,NULL);
	}
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x554c4f535f444e45, %r12 # imm = 0x554C4F535F444E45
movabsq $0x4e4f4954554c4f, %r13 # imm = 0x4E4F4954554C4F
leaq 0xed3d(%rip), %rsi      # 0x15500
callq 0x658c
movq 0xed31(%rip), %rax      # 0x15500
xorq %r12, %rax
movq 0xed2c(%rip), %rcx      # 0x15505
xorq %r13, %rcx
orq %rax, %rcx
je 0x6867
xorl %ebp, %ebp
leaq 0xed12(%rip), %r15      # 0x15500
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq 0x8(%rbx), %rax
movsd %xmm0, (%rax,%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq 0x8(%rbx), %rax
movsd %xmm0, 0x8(%rax,%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq 0x8(%rbx), %rax
movsd %xmm0, 0x10(%rax,%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq 0xecaf(%rip), %rax      # 0x15500
xorq %r12, %rax
movq 0xecaa(%rip), %rcx      # 0x15505
xorq %r13, %rcx
addq $0x18, %rbp
orq %rax, %rcx
jne 0x67ee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xeb41(%rip), %rsi      # 0x155f0
callq 0x658c
movl $0x4c495254, %eax       # imm = 0x4C495254
xorl 0xeb31(%rip), %eax      # 0x155f0
movzbl 0xeb2e(%rip), %ecx      # 0x155f4
orl %eax, %ecx
je 0x6ae0
movl $0x1, %edi
movl $0x3a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbc50
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd2cc
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xeb13(%rip), %r14      # 0x15640
movq %r14, %rsi
callq 0x658c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
leaq 0xe8c2(%rip), %rax      # 0x15408
movsd %xmm0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x658c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
leaq 0xe8aa(%rip), %rax      # 0x15410
movsd %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe8b3(%rip), %rax      # 0x1542c
movl $0x1, (%rax)
leaq 0xe8a2(%rip), %rax      # 0x15428
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0xe89f(%rip), %rax      # 0x15430
movl %ecx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe88d(%rip), %rax      # 0x15428
movl $0x1, (%rax)
leaq 0xe884(%rip), %rax      # 0x1542c
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0xe87d(%rip), %rax      # 0x15430
movl %ecx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0xe86b(%rip), %rax      # 0x15428
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0xe864(%rip), %rax      # 0x1542c
movl %ecx, (%rax)
leaq 0xe85f(%rip), %rax      # 0x15430
movl $0x1, (%rax)
xorl %edi, %edi
movl $0x41, %esi
jmp 0xbc50
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x8ccc(%rip), %rsi      # 0xfca2
callq 0x1160
movq %rax, %r14
testq %rax, %rax
jne 0x6ff2
movl $0x2, %edi
movl $0x32, %esi
callq 0xbc50
xorl %edi, %edi
movl $0x33, %esi
callq 0xbc50
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
jne 0x7053
leaq 0xe71f(%rip), %r15      # 0x15730
movabsq $0x4e4f4954554c4f53, %r12 # imm = 0x4E4F4954554C4F53
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq 0xe703(%rip), %rax      # 0x15730
xorq %r12, %rax
movzbl 0xe701(%rip), %ecx      # 0x15738
orq %rax, %rcx
jne 0x7047
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6797
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x701b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x70d5
testl %edi, %edi
je 0x70ce
cvtsi2ss %edi, %xmm0
cvtsi2ssl 0xe707(%rip), %xmm1 # 0x15780
divss %xmm1, %xmm0
mulss 0x6f7f(%rip), %xmm0     # 0xe004
cvttss2si %xmm0, %ebx
cmpl %ebx, 0xe701(%rip)      # 0x15790
jge 0x70c3
testl %ebx, %ebx
jle 0x70af
movq 0xdf5c(%rip), %r14      # 0x14ff8
movl %ebx, %ebp
movq (%r14), %rsi
movl $0x3e, %edi
callq 0x10e0
decl %ebp
jne 0x709e
movq 0xdf42(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10e0
movl %ebx, 0xe6c7(%rip)      # 0x15790
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2cb4
jmp 0x70c9
callq 0x2c98
jmp 0x70c9
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl $0x3, %edi
movl $0x3, %esi
callq 0xbcb0
movq %rax, 0xe6a5(%rip)      # 0x15798
movl $0x40, %edi
callq 0xce68
movq %rax, 0xe69c(%rip)      # 0x157a0
testq %rax, %rax
jne 0x7118
movl $0x2, %edi
movl $0x6c, %esi
callq 0xbc50
movl $0x40, %edi
callq 0xce68
movq %rax, 0xe67f(%rip)      # 0x157a8
testq %rax, %rax
jne 0x713d
movl $0x2, %edi
movl $0x6c, %esi
callq 0xbc50
xorl %ebx, %ebx
movl $0x3, %edi
movl $0x3, %esi
callq 0xbcb0
movq 0xe64b(%rip), %rcx      # 0x157a0
movq %rax, (%rcx,%rbx,8)
movl $0x3, %edi
movl $0x3, %esi
callq 0xbcb0
movq 0xe639(%rip), %rcx      # 0x157a8
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq $0x8, %rbx
jne 0x713f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbc50
leaq 0xe2a2(%rip), %rax      # 0x15434
cmpl $0x0, (%rax)
je 0x71a3
movl $0x3, %edi
movl $0x3, %esi
jmp 0x71ae
movl 0xe5d7(%rip), %eax      # 0x15780
leal (%rax,%rax,2), %edi
movl %edi, %esi
callq 0xbcb0
leaq 0xe286(%rip), %rcx      # 0x15440
movq %rax, (%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xbf13
movl 0xe5b3(%rip), %eax      # 0x15780
leal (%rax,%rax,2), %edi
callq 0xbde7
leaq 0xe26c(%rip), %rcx      # 0x15448
movq %rax, (%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xc2f3
callq 0x70dc
movl $0x3, %edi
movl $0x3, %esi
callq 0xbcb0
movq %rax, 0xe5ac(%rip)      # 0x157b0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x65, %esi
callq 0xbc50
movq 0xe57c(%rip), %rdi      # 0x15798
callq 0xbe4b
movq 0xe588(%rip), %rdi      # 0x157b0
callq 0xbe4b
movq 0xe56c(%rip), %rax      # 0x157a0
movq (%rax,%rbx,8), %rdi
callq 0xbe4b
movq 0xe564(%rip), %rax      # 0x157a8
movq (%rax,%rbx,8), %rdi
callq 0xbe4b
incq %rbx
cmpq $0x8, %rbx
jne 0x722d
movq 0xe543(%rip), %rdi      # 0x157a0
callq 0xce88
movq 0xe53f(%rip), %rdi      # 0x157a8
popq %rbx
jmp 0xce88
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: init_normal_integrationc
void init_normal_integrationc( point sn, element e )
{ /* IN:          sourcenode 'sn', element e;
   * OUT:         nothing
   * MODIFIES:    the matrix arrays ctf[] and cuf[]
   * USES:        fsol3d module
   * DESCRIPTION: This function fills the matrix arrays cuf[] and ctf[] with
   *              the fundamental solutions in the gauss points. This is 
   *              done once for each element.
   */
int i;            /* counter */
double cx, cy, cz;  /* fieldpoint coordinates */

   for (i=1; i<=7; i++)
   { cx = cxi1[i]*e->p1x + cxi2[i]*e->p2x + cxi3[i]*e->p3x;
     cy = cxi1[i]*e->p1y + cxi2[i]*e->p2y + cxi3[i]*e->p3y;
     cz = cxi1[i]*e->p1z + cxi2[i]*e->p2z + cxi3[i]*e->p3z;
     makeUFandTF(cuf[i],ctf[i],sn->x,sn->y,sn->z,cx,cy,cz,e->nx,e->ny,e->nz);
   }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0xde76(%rip), %r12      # 0x15100
leaq 0xdeaf(%rip), %r13      # 0x15140
leaq 0xdee8(%rip), %rbp      # 0x15180
movsd 0x8(%r15,%r12), %xmm0
movsd 0x8(%r15,%r13), %xmm1
movsd 0x40(%rbx), %xmm2
mulsd %xmm1, %xmm2
movsd 0x28(%rbx), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm2, %xmm4
movsd 0x8(%r15,%rbp), %xmm5
movsd 0x58(%rbx), %xmm3
mulsd %xmm5, %xmm3
addsd %xmm4, %xmm3
movsd 0x48(%rbx), %xmm2
mulsd %xmm1, %xmm2
movsd 0x30(%rbx), %xmm6
mulsd %xmm0, %xmm6
addsd %xmm2, %xmm6
movsd 0x60(%rbx), %xmm4
mulsd %xmm5, %xmm4
addsd %xmm6, %xmm4
mulsd 0x50(%rbx), %xmm1
mulsd 0x38(%rbx), %xmm0
mulsd 0x68(%rbx), %xmm5
addsd %xmm1, %xmm0
addsd %xmm0, %xmm5
movq 0xe497(%rip), %rax      # 0x157a8
movq 0x8(%rax,%r15), %rdi
movq 0xe483(%rip), %rax      # 0x157a0
movq 0x8(%rax,%r15), %rsi
movsd 0x20(%r14), %xmm0
movsd 0x28(%r14), %xmm1
movsd 0x30(%r14), %xmm2
movsd 0xa0(%rbx), %xmm6
movsd 0xa8(%rbx), %xmm7
movsd 0xb0(%rbx), %xmm8
movsd %xmm8, (%rsp)
callq 0xb524
addq $0x8, %r15
cmpq $0x38, %r15
jne 0x7298
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl 0x10(%rdi), %ecx
movl 0x18(%rsi), %eax
cmpl %eax, %ecx
je 0x75ec
cmpl 0x1c(%r15), %ecx
je 0x75dc
cmpl 0x20(%r15), %ecx
jne 0x75ff
cmpl %eax, %ecx
je 0x75ec
cmpl 0x1c(%r15), %ecx
je 0x75ec
cmpl 0x20(%r15), %ecx
jne 0x761a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x96a8
movq %r15, %rsi
callq 0x726f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x7375
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: make_rhs_vectorc
void make_rhs_vectorc(mesh theMesh)
{ restraint r;
  point p;

  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;
  }

  p=(point)point_dll(theMesh->mesh_p,START,0);
  while (p!=(point)NULL)
  { if (p->type==CNODE)
    { V(main_u,p->label*3-2)=0.0;
      V(main_u,p->label*3-1)=0.0;
      V(main_u,p->label*3  )=0.0;
    }
    p=p->NEXT;
  } 

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xdaab(%rip), %r14      # 0x15450
movq (%r14), %rdi
xorl %esi, %esi
callq 0xc2f3
leaq 0xda92(%rip), %rax      # 0x15448
movq (%rax), %rdi
xorl %esi, %esi
callq 0xc2f3
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd1d1
testq %rax, %rax
je 0x7a0b
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movsd 0x18(%rax), %xmm0
movslq 0x14(%rax), %rdx
leaq (%rdx,%rdx,2), %rdx
movsd %xmm0, -0x18(%rcx,%rdx,8)
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x10(%rcx,%rdx,8)
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x8(%rcx,%rdx,8)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x79d9
movq 0x10(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd1d1
testq %rax, %rax
je 0x7a56
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movsd 0x30(%rax), %xmm0
movslq 0x14(%rax), %rdx
leaq (%rdx,%rdx,2), %rdx
movsd %xmm0, -0x18(%rcx,%rdx,8)
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x10(%rcx,%rdx,8)
movsd 0x40(%rax), %xmm0
movsd %xmm0, -0x8(%rcx,%rdx,8)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x7a24
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x7a96
movq (%r14), %rcx
xorps %xmm0, %xmm0
cmpl $0xf, 0x14(%rax)
jne 0x7a8d
movq 0x8(%rcx), %rdx
movslq 0x10(%rax), %rsi
leaq (%rsi,%rsi,2), %rsi
movups %xmm0, -0x18(%rdx,%rsi,8)
movq $0x0, -0x8(%rdx,%rsi,8)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x7a6d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: plug_inc
void plug_inc(int label, hypermatrix erow)
{ int i;
  for (i=1; i<=cn_nodes; i++)
  { M(main_E,label*3-2,i*3-2)=H(erow,1,1,i);
    M(main_E,label*3-2,i*3-1)=H(erow,1,2,i);
    M(main_E,label*3-2,i*3  )=H(erow,1,3,i);

    M(main_E,label*3-1,i*3-2)=H(erow,2,1,i);
    M(main_E,label*3-1,i*3-1)=H(erow,2,2,i);
    M(main_E,label*3-1,i*3  )=H(erow,2,3,i);

    M(main_E,label*3  ,i*3-2)=H(erow,3,1,i);
    M(main_E,label*3  ,i*3-1)=H(erow,3,2,i);
    M(main_E,label*3  ,i*3  )=H(erow,3,3,i);
  }
}

// Assembly:
movl 0xdcdb(%rip), %r8d      # 0x15780
testl %r8d, %r8d
jle 0x7b6c
movq 0x8(%rsi), %rax
leaq 0xd987(%rip), %rcx      # 0x15440
movq (%rcx), %rcx
movq 0x8(%rcx), %rsi
leal (%rdi,%rdi,2), %ecx
movslq %ecx, %rdi
movq -0x18(%rsi,%rdi,8), %rcx
movq -0x10(%rsi,%rdi,8), %rdx
movq -0x8(%rsi,%rdi,8), %rsi
addq $0x8, %rax
xorl %edi, %edi
shlq $0x3, %r8
leaq (%r8,%r8,2), %r8
movq (%rax), %r9
movq 0x8(%r9), %r9
movq (%r9), %r10
movsd (%r10), %xmm0
movsd %xmm0, (%rcx,%rdi)
movsd 0x8(%r10), %xmm0
movsd %xmm0, 0x8(%rcx,%rdi)
movsd 0x10(%r10), %xmm0
movsd %xmm0, 0x10(%rcx,%rdi)
movq 0x8(%r9), %r10
movsd (%r10), %xmm0
movsd %xmm0, (%rdx,%rdi)
movsd 0x8(%r10), %xmm0
movsd %xmm0, 0x8(%rdx,%rdi)
movsd 0x10(%r10), %xmm0
movsd %xmm0, 0x10(%rdx,%rdi)
movq 0x10(%r9), %r9
movsd (%r9), %xmm0
movsd %xmm0, (%rsi,%rdi)
movsd 0x8(%r9), %xmm0
movsd %xmm0, 0x8(%rsi,%rdi)
movsd 0x10(%r9), %xmm0
movsd %xmm0, 0x10(%rsi,%rdi)
addq $0x18, %rdi
addq $0x8, %rax
cmpq %rdi, %r8
jne 0x7ae3
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf2c(%rip), %rax      # 0x157c0
movsd 0x70(%rax), %xmm0
callq 0x1170
movsd %xmm0, 0xcf22(%rip)     # 0x157c8
movq 0xcf13(%rip), %rax      # 0x157c0
movsd 0x70(%rax), %xmm0
callq 0x10d0
movsd %xmm0, 0xcf11(%rip)     # 0x157d0
movq 0xcefa(%rip), %rax      # 0x157c0
movsd 0x78(%rax), %xmm0
callq 0x1170
movsd %xmm0, 0xcf00(%rip)     # 0x157d8
movq 0xcee1(%rip), %rax      # 0x157c0
movsd 0x78(%rax), %xmm0
callq 0x10d0
movsd %xmm0, 0xceef(%rip)     # 0x157e0
movq 0xcec8(%rip), %rax      # 0x157c0
movsd 0x80(%rax), %xmm0
callq 0x1170
movsd %xmm0, 0xcedb(%rip)     # 0x157e8
movq 0xceac(%rip), %rax      # 0x157c0
movsd 0x80(%rax), %xmm0
callq 0x10d0
movsd %xmm0, 0xcec7(%rip)     # 0x157f0
movq 0xce90(%rip), %rax      # 0x157c0
movups 0x28(%rax), %xmm0
movups %xmm0, 0xcecd(%rip)     # 0x15808
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0xced0(%rip)     # 0x15818
movups 0x40(%rax), %xmm0
movups %xmm0, 0xced5(%rip)     # 0x15828
movsd 0x50(%rax), %xmm0
movsd %xmm0, 0xced8(%rip)     # 0x15838
movups 0x58(%rax), %xmm0
movups %xmm0, 0xcedd(%rip)     # 0x15848
movsd 0x68(%rax), %xmm0
movsd %xmm0, 0xcee0(%rip)     # 0x15858
movups 0xa0(%rax), %xmm0
movups %xmm0, 0xcee2(%rip)     # 0x15868
movsd 0xb0(%rax), %xmm0
movsd %xmm0, 0xcee2(%rip)     # 0x15878
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xcc0f(%rip), %rax      # 0x157c0
movsd 0x78(%rax), %xmm0
mulsd 0x58aa(%rip), %xmm0     # 0xe468
callq 0x1140
movsd 0x543d(%rip), %xmm1     # 0xe008
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0xcbe4(%rip), %rax      # 0x157c0
movsd 0x5884(%rip), %xmm0     # 0xe468
mulsd 0x80(%rax), %xmm0
callq 0x1140
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, (%rax)
movapd %xmm1, %xmm0
callq 0x10c0
movq 0x8(%rbx), %rax
movsd %xmm0, (%rax)
movq 0xcba5(%rip), %rcx      # 0x157c0
movsd 0x98(%rcx), %xmm1
divsd 0x90(%rcx), %xmm1
movsd 0xcbbd(%rip), %xmm2     # 0x157f0
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd 0x63bd(%rip), %xmm1     # 0xf000
addsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rax)
mulsd 0x90(%rcx), %xmm2
divsd 0x88(%rcx), %xmm2
movsd %xmm2, 0x8(%rax)
movsd 0x90(%rcx), %xmm2
divsd 0x98(%rcx), %xmm2
movsd 0xcb67(%rip), %xmm3     # 0x157e0
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x10(%rax)
mulsd 0x98(%rcx), %xmm3
divsd 0x88(%rcx), %xmm3
movsd %xmm3, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_p_q_r
void make_p_q_r(const matrix p, const matrix q, const matrix r)
{ /* IN:          matrices p, q, r which have to be filled
   * OUT:         nothing
   * MODIFIES:    matrices p, q, r
   * USES:        theElement, n1, n2 and n3 arrays
   * DESCRIPTION:
   * The matrices p, q and r are calculated from the element data from
   * theElement. The results are put in the offered p, r and r matrices.
   */

double c;    /* :scalefactor for p, q and r */
double k213, /* :temporary storage: */
	 i213,
	 i312,
	 k312;
int  k, i; /* :counters */

  /* scalefactor c is given by 1/(sin(alpha1)^2): */
   c = sinA1 * sinA1;
   c = 1.0 / c;

   for (k=1; k<=3; k++)
   { k213 = (n2[k]-n1[k])/theElement->z3;
	 k312 = (n3[k]-n1[k])/theElement->z2;
	 for (i=1; i<=3; i++)
	 { i213 = (n2[i]-n1[i])/theElement->z3;
	   i312 = (n3[i]-n1[i])/theElement->z2;
	   M(p,k,i) = c * k213 * i213;
	   M(q,k,i) = c * ( k213*i312 + i213*k312 ); 
	   M(r,k,i) = c * k312 * i312;
	 } /* for i */
   } /* for k */

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movsd 0xcb16(%rip), %xmm1     # 0x157c8
mulsd %xmm1, %xmm1
movsd 0x534a(%rip), %xmm0     # 0xe008
divsd %xmm1, %xmm0
movq 0xcaf7(%rip), %rax      # 0x157c0
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rsi
movq 0x8(%rdx), %rdx
movl $0x1, %edi
leaq 0xcb3f(%rip), %r8       # 0x15820
leaq 0xcb18(%rip), %r9       # 0x15800
leaq 0xcb51(%rip), %r10      # 0x15840
movsd (%r8,%rdi,8), %xmm1
movsd (%r9,%rdi,8), %xmm3
subsd %xmm3, %xmm1
divsd 0x98(%rax), %xmm1
movsd (%r10,%rdi,8), %xmm2
subsd %xmm3, %xmm2
divsd 0x90(%rax), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm1, %xmm3
movq -0x8(%rcx,%rdi,8), %r11
movq -0x8(%rsi,%rdi,8), %rbx
movapd %xmm0, %xmm4
mulsd %xmm2, %xmm4
movq -0x8(%rdx,%rdi,8), %r14
xorl %r15d, %r15d
movsd 0x8(%r15,%r8), %xmm5
movsd 0x8(%r15,%r9), %xmm6
subsd %xmm6, %xmm5
divsd 0x98(%rax), %xmm5
movsd 0x8(%r15,%r10), %xmm7
subsd %xmm6, %xmm7
divsd 0x90(%rax), %xmm7
movapd %xmm3, %xmm6
mulsd %xmm5, %xmm6
movsd %xmm6, (%r11,%r15)
mulsd %xmm2, %xmm5
movapd %xmm1, %xmm6
mulsd %xmm7, %xmm6
addsd %xmm5, %xmm6
mulsd %xmm0, %xmm6
movsd %xmm6, (%rbx,%r15)
mulsd %xmm4, %xmm7
movsd %xmm7, (%r14,%r15)
addq $0x8, %r15
cmpq $0x18, %r15
jne 0x8d3b
incq %rdi
cmpq $0x4, %rdi
jne 0x8cef
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_A
void make_A(const matrix p, const matrix q, const matrix r, const double beta, 
			const matrix A)
{ /* IN:          matrices p, q and r, double beta, matrix A
   * OUT:         nothing
   * MODIFIES:    matrix A
   * USES:        data from theElement
   * DESCRIPTION: This function, of course, calculates the A matrix.
   */

int  k, i; /* :counters */
double A1, A2, A3;

   for (k=1; k<=3; k++)
   { for (i=1; i<=3; i++)
	 { A1 = cosA3
		  - cos( theElement->alpha3-theElement->alpha1 )
		  + beta * sinA3 * sinA3;
       A1 = M(p,k,i) * A1;
       
	   A2 = cosA2
		  + cosA3
		  - beta * sinA2 * sinA3;
       A2 = M(q,k,i) * A2;

       A3 = cosA2
		  - cos( theElement->alpha2-theElement->alpha1 )
		  + beta * sinA2 * sinA2;
       A3 = M(r,k,i) * A3;

	   M(A,k,i) = A1 + A2 + A3;
	 } /* for i */
   }  /* for k */

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movl $0x1, %r13d
movapd %xmm1, 0x10(%rsp)
xorl %ebp, %ebp
movq 0xc9c9(%rip), %rax      # 0x157c0
movsd 0x80(%rax), %xmm0
subsd 0x70(%rax), %xmm0
movsd 0xc9e4(%rip), %xmm1     # 0x157f0
movaps %xmm1, 0x70(%rsp)
callq 0x10d0
movapd %xmm0, 0x60(%rsp)
movsd 0xc9c4(%rip), %xmm2     # 0x157e8
movapd %xmm2, 0x50(%rsp)
movq 0x8(%r12), %rax
movq -0x8(%rax,%r13,8), %rax
movsd 0xc9a4(%rip), %xmm0     # 0x157e0
movapd %xmm0, 0x30(%rsp)
movsd 0xc9a6(%rip), %xmm1     # 0x157f0
addsd %xmm0, %xmm1
movsd 0xc982(%rip), %xmm0     # 0x157d8
mulsd 0x20(%rsp), %xmm0
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movq 0x8(%r15), %rcx
movq -0x8(%rcx,%r13,8), %rcx
mulsd (%rcx,%rbp,8), %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0xc941(%rip), %rcx      # 0x157c0
movsd 0x78(%rcx), %xmm0
subsd 0x70(%rcx), %xmm0
movsd (%rax,%rbp,8), %xmm1
movaps %xmm1, 0x40(%rsp)
callq 0x10d0
movapd 0x10(%rsp), %xmm1
movq 0x8(%r14), %rax
movq -0x8(%rax,%r13,8), %rax
movapd 0x70(%rsp), %xmm2
unpcklpd 0x30(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x60(%rsp), %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
movapd 0x50(%rsp), %xmm3
movhpd 0xc90d(%rip), %xmm3     # xmm3 = xmm3[0],mem[0]
subpd %xmm4, %xmm2
movapd %xmm3, %xmm0
mulpd %xmm1, %xmm0
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
movapd 0x40(%rsp), %xmm2
movhpd (%rax,%rbp,8), %xmm2    # xmm2 = xmm2[0],mem[0]
mulpd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
addsd %xmm2, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm0, %xmm2
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r13,8), %rax
movsd %xmm2, (%rax,%rbp,8)
incq %rbp
cmpq $0x3, %rbp
jne 0x8df0
incq %r13
cmpq $0x4, %r13
jne 0x8dee
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_D
void make_D( const matrix D, const double beta )
{ /* IN:          matrix D, beta
   * OUT:         nothing 
   * MODIFIES:    matrix D
   * USES:        data from theElement
   * DESCRIPTION: This function fills the D matrix and returns the value
   *              for beta, which has to be used for calculating the 
   *              S matrix.
   */

   M(D,2,3) = (n3[1]-n2[1])/theElement->z1;
   M(D,2,3) = M(D,2,3) * beta;

   M(D,3,1) = (n3[2]-n2[2])/theElement->z1;
   M(D,3,1) = M(D,3,1) * beta;

   M(D,1,2) = (n3[3]-n2[3])/theElement->z1;
   M(D,1,2) = M(D,1,2) * beta;

   M(D,3,2) = -M(D,2,3); 
   M(D,1,3) = -M(D,3,1);
   M(D,2,1) = -M(D,1,2);

   M(D,1,1) = 0.0;
   M(D,2,2) = 0.0;
   M(D,3,3) = 0.0;

}

// Assembly:
movsd 0xc4c6(%rip), %xmm1     # 0x15848
subsd 0xc49e(%rip), %xmm1     # 0x15828
movq 0xc42f(%rip), %rcx      # 0x157c0
divsd 0x88(%rcx), %xmm1
movq 0x8(%rdi), %rdx
movq 0x8(%rdx), %rax
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rax)
movsd 0xc49e(%rip), %xmm1     # 0x15850
subsd 0xc476(%rip), %xmm1     # 0x15830
divsd 0x88(%rcx), %xmm1
movq 0x10(%rdx), %rsi
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsi)
movsd 0xc482(%rip), %xmm1     # 0x15858
subsd 0xc45a(%rip), %xmm1     # 0x15838
divsd 0x88(%rcx), %xmm1
movq (%rdx), %rcx
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rcx)
movsd 0x10(%rax), %xmm0
movaps 0x4c22(%rip), %xmm1     # 0xe020
xorps %xmm1, %xmm0
movlps %xmm0, 0x8(%rsi)
movsd (%rsi), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, 0x10(%rcx)
movsd 0x8(%rcx), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, (%rcx)
movq %rdx, 0x8(%rax)
movq %rdx, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_S
void make_S( const matrix S, const double beta )
{ /* IN:          Matrix S, beta
   * OUT:         nothing
   * MODIFIES:    matrix S
   * USES:        data from theElement, beta as calculated in make_D()
   * DESCRIPTION: Fills matrix S
   */

int  i;    /* counter */
double i312, /* :temporary storage: */
	 i321;

   for (i=1; i<=3; i++)
   { i312 = (n3[i]-n1[i])/theElement->z2;
	 i321 = (n3[i]-n2[i])/theElement->z1;

	/* first component: */
	 M(S,i,1) = i312 * (cosA2 + cosA3)
			  - i321 * (1.0 - cosA1);
     M(S,i,1) = M(S,i,1) / sinA3;

	/* second component: */
     M(S,i,2) = cos(theElement->alpha3-theElement->alpha1);
	 M(S,i,2) = cosA3 - M(S,i,2) + beta*sinA3*sinA3;
	 M(S,i,2) = i321 * M(S,i,2);
	 M(S,i,2) = -i312 * (1.0-cosA1) + M(S,i,2);
	 M(S,i,2) = M(S,i,2) * theElement->z2 / theElement->z1 / sinA3;

	/* third component: */
	 M(S,i,3) = cosA3 + cosA2 - beta*sinA2*sinA3;
	 M(S,i,3) = M(S,i,3) * i321;
	 M(S,i,3) = -i312 * (1.0-cosA1) + M(S,i,3);
	 M(S,i,3) = M(S,i,3) * theElement->z2 / theElement->z1 / sinA2;

   } /* for i */

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xc3f8(%rip), %r15      # 0x15840
leaq 0xc3b1(%rip), %r12      # 0x15800
leaq 0xc3ca(%rip), %r13      # 0x15820
movsd 0x8(%r14,%r15), %xmm2
movapd %xmm2, %xmm0
subsd 0x8(%r14,%r12), %xmm0
movq 0xc351(%rip), %rax      # 0x157c0
divsd 0x90(%rax), %xmm0
movapd %xmm0, %xmm3
movapd %xmm0, 0x10(%rsp)
subsd 0x8(%r14,%r13), %xmm2
divsd 0x88(%rax), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0xc342(%rip), %xmm0     # 0x157e0
addsd 0xc34a(%rip), %xmm0     # 0x157f0
movsd 0x4b5a(%rip), %xmm1     # 0xe008
subsd 0xc31a(%rip), %xmm1     # 0x157d0
mulsd %xmm2, %xmm1
mulsd %xmm3, %xmm0
subsd %xmm1, %xmm0
movq 0x8(%rbx), %rcx
movq (%rcx,%r14), %rcx
movsd %xmm0, (%rcx)
divsd 0xc312(%rip), %xmm0     # 0x157e8
movsd %xmm0, (%rcx)
movsd 0x80(%rax), %xmm0
subsd 0x70(%rax), %xmm0
callq 0x10d0
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rax
movsd %xmm0, 0x8(%rax)
movsd 0xc2ef(%rip), %xmm1     # 0x157f0
movapd %xmm1, %xmm3
movsd 0xc2db(%rip), %xmm2     # 0x157e8
movapd %xmm2, %xmm4
movsd (%rsp), %xmm5
mulsd %xmm5, %xmm4
subsd %xmm0, %xmm3
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
movsd 0x8(%rsp), %xmm6
mulsd %xmm6, %xmm4
movsd %xmm4, 0x8(%rax)
movsd 0x4acb(%rip), %xmm0     # 0xe008
subsd 0xc28b(%rip), %xmm0     # 0x157d0
movapd 0x10(%rsp), %xmm3
xorpd 0x4acd(%rip), %xmm3     # 0xe020
mulsd %xmm3, %xmm0
addsd %xmm0, %xmm4
movsd %xmm4, 0x8(%rax)
movq 0xc259(%rip), %rcx      # 0x157c0
mulsd 0x90(%rcx), %xmm4
divsd 0x88(%rcx), %xmm4
divsd %xmm2, %xmm4
movsd %xmm4, 0x8(%rax)
addsd 0xc258(%rip), %xmm1     # 0x157e0
movsd 0xc248(%rip), %xmm3     # 0x157d8
movapd %xmm3, %xmm4
mulsd %xmm5, %xmm4
mulsd %xmm2, %xmm4
subsd %xmm4, %xmm1
mulsd %xmm6, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rax)
mulsd 0x90(%rcx), %xmm1
divsd 0x88(%rcx), %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x10(%rax)
addq $0x8, %r14
cmpq $0x18, %r14
jne 0x9456
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq