LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x9014(%rip), %rdi      # 0xeda0
callq 0x1060
leaq 0x8f18(%rip), %rdi      # 0xecb0
callq 0x1060
leaq 0x8f13(%rip), %rdi      # 0xecb7
callq 0x1060
leaq 0x8f12(%rip), %rdi      # 0xecc2
callq 0x1060
leaq 0x8ec6(%rip), %rdi      # 0xec82
callq 0x1060
leaq 0x8f0b(%rip), %rdi      # 0xecd3
callq 0x1060
leaq 0x8f16(%rip), %rdi      # 0xecea
callq 0x1060
leaq 0x8f1b(%rip), %rdi      # 0xecfb
callq 0x1060
leaq 0x8f1a(%rip), %rdi      # 0xed06
callq 0x1060
leaq 0x8f3c(%rip), %rdi      # 0xed34
callq 0x1060
leaq 0x8f35(%rip), %rdi      # 0xed39
callq 0x1060
leaq 0x87bb(%rip), %rdi      # 0xe5cb
xorl %eax, %eax
callq 0x1090
leaq 0x8f58(%rip), %rdi      # 0xed76
callq 0x1060
leaq 0x8f61(%rip), %rdi      # 0xed8b
callq 0x1060
leaq 0x87d2(%rip), %r14      # 0xe608
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
leaq 0x87f5(%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 0xcc2f
testq %rax, %rax
je 0x5eb2
movq %rax, %rbx
leaq 0x87ef(%rip), %r14      # 0xe66b
leaq 0x8825(%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 0x5e83
leaq 0x8ee7(%rip), %rdi      # 0xeda0
popq %rbx
popq %r14
popq %r15
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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 0x64f2
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 0x64a6
movl %ebp, %ecx
sarl $0x18, %ecx
cmpl $0x7d000000, %ebp       # imm = 0x7D000000
movl $0x20, %eax
cmovnel %ecx, %eax
jmp 0x64f7
movl $0x20, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x649c
movl %eax, %ebp
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
jne 0x657e
callq 0x11c0
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x650a
xorl %r12d, %r12d
movl %ebp, %edi
callq 0x1050
movb %al, (%rbx,%r12)
cmpq $0x4f, %r12
jb 0x6558
movl $0x1, %edi
movl $0x3a, %esi
callq 0xb980
movq %r14, %rdi
callq 0x649c
movl %eax, %edi
callq 0x1050
movl %eax, %ebp
movq (%r15), %rax
movslq %ebp, %rcx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
je 0x6538
movl %r12d, %eax
jmp 0x658c
movw $0x4e45, (%rbx)         # imm = 0x4E45
movb $0x44, 0x2(%rbx)
movl $0x3, %eax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeea7(%rip), %rsi      # 0x15460
callq 0x64fc
movq 0xee9b(%rip), %rax      # 0x15460
xorq %r13, %rax
movzwl 0xee99(%rip), %ecx      # 0x15468
xorq $0x53, %rcx
orq %rax, %rcx
je 0x668c
leaq 0xee7d(%rip), %r15      # 0x15460
movq (%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xcc2f
movq %rax, %r12
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1180
movl %eax, 0x10(%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq (%rbx), %rax
movsd %xmm0, 0x20(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq (%rbx), %rax
movsd %xmm0, 0x28(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
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 0x64fc
movq 0xedeb(%rip), %rax      # 0x15460
xorq %r13, %rax
movzwl 0xede9(%rip), %ecx      # 0x15468
xorq $0x53, %rcx
orq %rax, %rcx
jne 0x65e3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xed8c(%rip), %rax      # 0x15434
movl $0x1, (%rax)
leaq 0xedfb(%rip), %r14      # 0x154b0
movabsq $0x554c4f535f444e45, %r15 # imm = 0x554C4F535F444E45
movabsq $0x4e4f4954554c4f, %r12 # imm = 0x4E4F4954554C4F
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64fc
movq 0xedd5(%rip), %rax      # 0x154b0
xorq %r15, %rax
movq 0xedd0(%rip), %rcx      # 0x154b5
xorq %r12, %rcx
orq %rax, %rcx
jne 0x66c9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeddb(%rip), %rsi      # 0x15500
callq 0x64fc
movq 0xedcf(%rip), %rax      # 0x15500
xorq %r12, %rax
movq 0xedca(%rip), %rcx      # 0x15505
xorq %r13, %rcx
orq %rax, %rcx
je 0x67c9
xorl %ebp, %ebp
leaq 0xedb0(%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 0x64fc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq 0x8(%rbx), %rax
movsd %xmm0, 0x8(%rax,%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq 0x8(%rbx), %rax
movsd %xmm0, 0x10(%rax,%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq 0xed4d(%rip), %rax      # 0x15500
xorq %r12, %rax
movq 0xed48(%rip), %rcx      # 0x15505
xorq %r13, %rcx
addq $0x18, %rbp
orq %rax, %rcx
jne 0x6750
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: fill_C_points
void fill_C_points(FILE *fp, cmesh theCMesh)
{ point p; 
  point q;
  int node1label;
  int node2label;
  double length;
  static char theKeyword[80];
  while (1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_CNODES")) return;
    node1label=atoi(theKeyword);
    read_keyword(fp,theKeyword); 
    node2label=atoi(theKeyword)+theCMesh->nr_of_nodes_basemesh;
    p=(point)point_dll(theCMesh->merged_mesh->mesh_p,SEARCH,node1label);
    q=(point)point_dll(theCMesh->merged_mesh->mesh_p,SEARCH,node2label);
    p->type=CNODE; q->type=CNODE;
    p->conn=q->label; q->conn=p->label;
    read_keyword(fp,theKeyword); p->n1=strtod(theKeyword,NULL);
    read_keyword(fp,theKeyword); p->n2=strtod(theKeyword,NULL);
    read_keyword(fp,theKeyword); p->n3=strtod(theKeyword,NULL);
    length=sqrt(p->n1*p->n1+p->n2*p->n2+p->n3*p->n3);
    p->n1/=length;
    p->n2/=length;
    p->n3/=length;
    q->n1=p->n1;
    q->n2=p->n2;
    q->n3=p->n3;
     
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x444f4e435f444e45, %r12 # imm = 0x444F4E435F444E45
movabsq $0x5345444f4e435f, %r15 # imm = 0x5345444F4E435F
leaq 0xed46(%rip), %rsi      # 0x155a0
callq 0x64fc
movq 0xed3a(%rip), %rax      # 0x155a0
xorq %r12, %rax
movq 0xed33(%rip), %rcx      # 0x155a3
xorq %r15, %rcx
orq %rax, %rcx
je 0x69cc
leaq 0xed1d(%rip), %r15      # 0x155a0
movq %r15, %rdi
callq 0x1180
movl %eax, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
callq 0x1180
movl %eax, %r13d
addl 0x8(%rbx), %r13d
movq (%rbx), %rax
movq (%rax), %rdi
movl $0x2, %esi
movl %ebp, %edx
callq 0xcc2f
movq %r12, %rbp
movq %rax, %r12
movq (%rbx), %rax
movq (%rax), %rdi
movl $0x2, %esi
movl %r13d, %edx
callq 0xcc2f
movq %rax, %r13
movl $0xf, %eax
movl %eax, 0x14(%r12)
movl %eax, 0x14(%r13)
movl 0x10(%r13), %eax
movl %eax, 0x18(%r12)
movl 0x10(%r12), %eax
movl %eax, 0x18(%r13)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movsd %xmm0, 0x68(%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movsd %xmm0, 0x70(%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movupd 0x68(%r12), %xmm1
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
sqrtsd %xmm2, %xmm2
divsd %xmm2, %xmm0
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x68(%r12)
movsd %xmm0, 0x78(%r12)
movq %rbp, %r12
movupd %xmm1, 0x68(%r13)
movsd %xmm0, 0x78(%r13)
movabsq $0x5345444f4e435f, %r13 # imm = 0x5345444F4E435F
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq 0xebea(%rip), %rax      # 0x155a0
xorq %rbp, %rax
movq 0xebe3(%rip), %rcx      # 0x155a3
xorq %r13, %rcx
orq %rax, %rcx
jne 0x6883
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xec04(%rip), %rsi      # 0x155f0
callq 0x64fc
movl $0x4c495254, %eax       # imm = 0x4C495254
xorl 0xebf4(%rip), %eax      # 0x155f0
movzbl 0xebf1(%rip), %ecx      # 0x155f4
orl %eax, %ecx
je 0x6a1d
movl $0x1, %edi
movl $0x3a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb980
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcfe4
// File: /workspace/github_c_makefile_star2_O3/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 0xebd6(%rip), %r14      # 0x15640
movq %r14, %rsi
callq 0x64fc
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
leaq 0xe985(%rip), %rax      # 0x15408
movsd %xmm0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64fc
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
leaq 0xe96d(%rip), %rax      # 0x15410
movsd %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe976(%rip), %rax      # 0x1542c
movl $0x1, (%rax)
leaq 0xe965(%rip), %rax      # 0x15428
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0xe962(%rip), %rax      # 0x15430
movl %ecx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe950(%rip), %rax      # 0x15428
movl $0x1, (%rax)
leaq 0xe947(%rip), %rax      # 0x1542c
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0xe940(%rip), %rax      # 0x15430
movl %ecx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe92e(%rip), %rax      # 0x15428
xorl %ecx, %ecx
movl %ecx, (%rax)
leaq 0xe927(%rip), %rax      # 0x1542c
movl %ecx, (%rax)
leaq 0xe922(%rip), %rax      # 0x15430
movl $0x1, (%rax)
xorl %edi, %edi
movl $0x41, %esi
jmp 0xb980
// File: /workspace/github_c_makefile_star2_O3/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 0x8d8f(%rip), %rsi      # 0xfca2
callq 0x1160
movq %rax, %r14
testq %rax, %rax
jne 0x6f2f
movl $0x2, %edi
movl $0x32, %esi
callq 0xb980
xorl %edi, %edi
movl $0x33, %esi
callq 0xb980
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
jne 0x6f90
leaq 0xe7e2(%rip), %r15      # 0x15730
movabsq $0x4e4f4954554c4f53, %r12 # imm = 0x4E4F4954554C4F53
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq 0xe7c6(%rip), %rax      # 0x15730
xorq %r12, %rax
movzbl 0xe7c4(%rip), %ecx      # 0x15738
orq %rax, %rcx
jne 0x6f84
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66f9
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x6f58
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7011
testl %edi, %edi
je 0x700a
cvtsi2ss %edi, %xmm0
cvtsi2ssl 0xe7cb(%rip), %xmm1 # 0x15780
divss %xmm1, %xmm0
mulss 0x7043(%rip), %xmm0     # 0xe004
cvttss2si %xmm0, %ebx
cmpl %ebx, 0xe7c5(%rip)      # 0x15790
jge 0x6fff
testl %ebx, %ebx
jle 0x6feb
movq 0xe020(%rip), %r14      # 0x14ff8
movl %ebx, %ebp
movq (%r14), %rsi
movl $0x3e, %edi
callq 0x10e0
decl %ebp
jne 0x6fda
movq 0xe006(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10e0
movl %ebx, 0xe78b(%rip)      # 0x15790
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2cf7
jmp 0x7005
callq 0x2cdb
jmp 0x7005
// File: /workspace/github_c_makefile_star2_O3/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 0xb9e0
movq %rax, 0xe769(%rip)      # 0x15798
movl $0x40, %edi
callq 0xcb90
movq %rax, 0xe760(%rip)      # 0x157a0
testq %rax, %rax
jne 0x7054
movl $0x2, %edi
movl $0x6c, %esi
callq 0xb980
movl $0x40, %edi
callq 0xcb90
movq %rax, 0xe743(%rip)      # 0x157a8
testq %rax, %rax
jne 0x7079
movl $0x2, %edi
movl $0x6c, %esi
callq 0xb980
xorl %ebx, %ebx
movl $0x3, %edi
movl $0x3, %esi
callq 0xb9e0
movq 0xe70f(%rip), %rcx      # 0x157a0
movq %rax, (%rcx,%rbx,8)
movl $0x3, %edi
movl $0x3, %esi
callq 0xb9e0
movq 0xe6fd(%rip), %rcx      # 0x157a8
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq $0x8, %rbx
jne 0x707b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb980
leaq 0xe366(%rip), %rax      # 0x15434
cmpl $0x0, (%rax)
je 0x70df
movl $0x3, %edi
movl $0x3, %esi
jmp 0x70ea
movl 0xe69b(%rip), %eax      # 0x15780
leal (%rax,%rax,2), %edi
movl %edi, %esi
callq 0xb9e0
leaq 0xe34a(%rip), %rcx      # 0x15440
movq %rax, (%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xbc43
movl 0xe677(%rip), %eax      # 0x15780
leal (%rax,%rax,2), %edi
callq 0xbb17
leaq 0xe330(%rip), %rcx      # 0x15448
movq %rax, (%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xc023
callq 0x7018
movl $0x3, %edi
movl $0x3, %esi
callq 0xb9e0
movq %rax, 0xe670(%rip)      # 0x157b0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb980
movq 0xe640(%rip), %rdi      # 0x15798
callq 0xbb7b
movq 0xe64c(%rip), %rdi      # 0x157b0
callq 0xbb7b
movq 0xe630(%rip), %rax      # 0x157a0
movq (%rax,%rbx,8), %rdi
callq 0xbb7b
movq 0xe628(%rip), %rax      # 0x157a8
movq (%rax,%rbx,8), %rdi
callq 0xbb7b
incq %rbx
cmpq $0x8, %rbx
jne 0x7169
movq 0xe607(%rip), %rdi      # 0x157a0
callq 0xcbb0
movq 0xe603(%rip), %rdi      # 0x157a8
popq %rbx
jmp 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 0xdf3a(%rip), %r12      # 0x15100
leaq 0xdf73(%rip), %r13      # 0x15140
leaq 0xdfac(%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 0xe55b(%rip), %rax      # 0x157a8
movq 0x8(%rax,%r15), %rdi
movq 0xe547(%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 0xb2c4
addq $0x8, %r15
cmpq $0x38, %r15
jne 0x71d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpl 0x18(%rsi), %ecx
je 0x7510
cmpl 0x1c(%r15), %ecx
jne 0x7523
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x9562
cmpl 0x20(%r15), %ecx
jne 0x7535
cmpl 0x20(%r15), %ecx
je 0x7510
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rsi
callq 0x71ab
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x72b1
// File: /workspace/github_c_makefile_star2_O3/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 0xdbcc(%rip), %r14      # 0x15450
movq (%r14), %rdi
xorl %esi, %esi
callq 0xc023
leaq 0xdbb3(%rip), %rax      # 0x15448
movq (%rax), %rdi
xorl %esi, %esi
callq 0xc023
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcee9
testq %rax, %rax
je 0x78ea
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 0x78b8
movq 0x10(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcee9
testq %rax, %rax
je 0x7935
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 0x7903
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x7975
movq (%r14), %rcx
xorps %xmm0, %xmm0
cmpl $0xf, 0x14(%rax)
jne 0x796c
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 0x794c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xddfc(%rip), %r8d      # 0x15780
testl %r8d, %r8d
jle 0x7a4b
movq 0x8(%rsi), %rax
leaq 0xdaa8(%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 0x79c2
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd068(%rip), %rax      # 0x157c0
movsd 0x70(%rax), %xmm0
callq 0x1170
movsd %xmm0, 0xd05e(%rip)     # 0x157c8
movq 0xd04f(%rip), %rax      # 0x157c0
movsd 0x70(%rax), %xmm0
callq 0x10d0
movsd %xmm0, 0xd04d(%rip)     # 0x157d0
movq 0xd036(%rip), %rax      # 0x157c0
movsd 0x78(%rax), %xmm0
callq 0x1170
movsd %xmm0, 0xd03c(%rip)     # 0x157d8
movq 0xd01d(%rip), %rax      # 0x157c0
movsd 0x78(%rax), %xmm0
callq 0x10d0
movsd %xmm0, 0xd02b(%rip)     # 0x157e0
movq 0xd004(%rip), %rax      # 0x157c0
movsd 0x80(%rax), %xmm0
callq 0x1170
movsd %xmm0, 0xd017(%rip)     # 0x157e8
movq 0xcfe8(%rip), %rax      # 0x157c0
movsd 0x80(%rax), %xmm0
callq 0x10d0
movsd %xmm0, 0xd003(%rip)     # 0x157f0
movq 0xcfcc(%rip), %rax      # 0x157c0
movups 0x28(%rax), %xmm0
movups %xmm0, 0xd009(%rip)     # 0x15808
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0xd00c(%rip)     # 0x15818
movups 0x40(%rax), %xmm0
movups %xmm0, 0xd011(%rip)     # 0x15828
movsd 0x50(%rax), %xmm0
movsd %xmm0, 0xd014(%rip)     # 0x15838
movups 0x58(%rax), %xmm0
movups %xmm0, 0xd019(%rip)     # 0x15848
movsd 0x68(%rax), %xmm0
movsd %xmm0, 0xd01c(%rip)     # 0x15858
movups 0xa0(%rax), %xmm0
movups %xmm0, 0xd01e(%rip)     # 0x15868
movsd 0xb0(%rax), %xmm0
movsd %xmm0, 0xd01e(%rip)     # 0x15878
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcd4b(%rip), %rax      # 0x157c0
movsd 0x78(%rax), %xmm0
mulsd 0x59de(%rip), %xmm0     # 0xe460
callq 0x1140
movsd 0x5579(%rip), %xmm1     # 0xe008
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0xcd20(%rip), %rax      # 0x157c0
movsd 0x59b8(%rip), %xmm0     # 0xe460
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 0xcce1(%rip), %rcx      # 0x157c0
movsd 0x98(%rcx), %xmm1
divsd 0x90(%rcx), %xmm1
movsd 0xccf9(%rip), %xmm2     # 0x157f0
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd 0x64f9(%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 0xcca3(%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_O3/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 0xcc52(%rip), %xmm1     # 0x157c8
mulsd %xmm1, %xmm1
movsd 0x5486(%rip), %xmm0     # 0xe008
divsd %xmm1, %xmm0
movq 0xcc33(%rip), %rax      # 0x157c0
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rsi
movq 0x8(%rdx), %rdx
movl $0x1, %edi
leaq 0xcc7b(%rip), %r8       # 0x15820
leaq 0xcc54(%rip), %r9       # 0x15800
leaq 0xcc8d(%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 0x8bff
incq %rdi
cmpq $0x4, %rdi
jne 0x8bb3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcb05(%rip), %rax      # 0x157c0
movsd 0x80(%rax), %xmm0
subsd 0x70(%rax), %xmm0
movsd 0xcb20(%rip), %xmm1     # 0x157f0
movaps %xmm1, 0x70(%rsp)
callq 0x10d0
movapd %xmm0, 0x60(%rsp)
movsd 0xcb00(%rip), %xmm2     # 0x157e8
movapd %xmm2, 0x50(%rsp)
movq 0x8(%r12), %rax
movq -0x8(%rax,%r13,8), %rax
movsd 0xcae0(%rip), %xmm0     # 0x157e0
movapd %xmm0, 0x30(%rsp)
movsd 0xcae2(%rip), %xmm1     # 0x157f0
addsd %xmm0, %xmm1
movsd 0xcabe(%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 0xca7d(%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 0xca49(%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 0x8cb4
incq %r13
cmpq $0x4, %r13
jne 0x8cb2
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc608(%rip), %xmm1     # 0x15848
subsd 0xc5e0(%rip), %xmm1     # 0x15828
movq 0xc571(%rip), %rcx      # 0x157c0
divsd 0x88(%rcx), %xmm1
movq 0x8(%rdi), %rdx
movq 0x8(%rdx), %rax
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rax)
movsd 0xc5e0(%rip), %xmm1     # 0x15850
subsd 0xc5b8(%rip), %xmm1     # 0x15830
divsd 0x88(%rcx), %xmm1
movq 0x10(%rdx), %rsi
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsi)
movsd 0xc5c4(%rip), %xmm1     # 0x15858
subsd 0xc59c(%rip), %xmm1     # 0x15838
divsd 0x88(%rcx), %xmm1
movq (%rdx), %rcx
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rcx)
movsd 0x10(%rax), %xmm0
movaps 0x4d64(%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_O3/markpeerdeman[P]mbemm/src/emath/singular.c
// Function: make_E
void make_E( const matrix D, const matrix S, const hypermatrix E )
{ /* IN:          matrices D, S, hypermatrix E
   * OUT:         nothing
   * MODIFIES:    hypermatrix E
   * USES:        D, E, normal vector of theElement
   * DESCRIPTION:
   * This function calculates the Ekij hypermatrix.
   */

double scalefactor;  
int k, i, j; /* :counters */

scalefactor = 1.0-2.0*NU;

 for (j=1; j<=3; j++)
 { for (k=1; k<=3; k++)
   { for(i=1; i<=3; i++)
     { H(E,k,i,j) = normal[k] * M(S,i,j) - normal[i] * M(S,k,j);
	   if (j==1)
	   { /* add the delta term to E: */
		  H(E,k,i,j) = H(E,k,i,j) + M(D,k,i);
	   } /* if */
	   H(E,k,i,j) = H(E,k,i,j) * scalefactor;
     } /* for i */
   } /* for k */
 } /* for j */

}

// Assembly:
pushq %r14
pushq %rbx
leaq 0xbf5a(%rip), %rax      # 0x15410
movsd (%rax), %xmm1
addsd %xmm1, %xmm1
movsd 0x4b42(%rip), %xmm0     # 0xe008
subsd %xmm1, %xmm0
movq 0x8(%rsi), %rax
movq 0x8(%rdx), %rcx
movl $0x1, %edx
leaq 0xc382(%rip), %rsi      # 0x15860
movq (%rcx,%rdx,8), %r8
movq 0x8(%r8), %r8
movl $0x1, %r9d
movsd (%rsi,%r9,8), %xmm1
movq -0x8(%rax,%r9,8), %r10
movq -0x8(%r8,%r9,8), %r11
xorl %ebx, %ebx
movq (%rax,%rbx,8), %r14
movsd -0x8(%r10,%rdx,8), %xmm3
mulsd 0x8(%rsi,%rbx,8), %xmm3
movsd -0x8(%r14,%rdx,8), %xmm2
mulsd %xmm1, %xmm2
subsd %xmm3, %xmm2
movsd %xmm2, (%r11,%rbx,8)
cmpq $0x1, %rdx
jne 0x9539
movq 0x8(%rdi), %r14
movq -0x8(%r14,%r9,8), %r14
addsd (%r14,%rbx,8), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%r11,%rbx,8)
incq %rbx
cmpq $0x3, %rbx
jne 0x94fe
incq %r9
cmpq $0x4, %r9
jne 0x94ec
incq %rdx
cmpq $0x4, %rdx
jne 0x94de
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9855
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb570
testq %rax, %rax
je 0x984d
movq %rax, %r14
movq (%rbx), %rsi
movq %r14, %rdi
callq 0xd264
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x9839
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x98ff
movsd 0xc01a(%rip), %xmm0     # 0x15880
movsd %xmm0, 0x30(%rbx)
movq %rbx, %rdi
callq 0x9b54
movsd 0xc00d(%rip), %xmm0     # 0x15888
movapd 0x478d(%rip), %xmm1     # 0xe010
andpd %xmm0, %xmm1
ucomisd 0x5a19(%rip), %xmm1     # 0xf2a8
jbe 0x98a3
leaq 0xbb70(%rip), %rax      # 0x15408
mulsd (%rax), %xmm0
divsd 0x30(%rbx), %xmm0
jmp 0x98ab
movsd 0xbfe5(%rip), %xmm0     # 0x15890
movsd %xmm0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x9cf6
movsd 0xbfd0(%rip), %xmm0     # 0x15890
andpd 0x4748(%rip), %xmm0     # 0xe010
ucomisd 0x59d8(%rip), %xmm0     # 0xf2a8
jbe 0x98e9
movsd 0x40(%rbx), %xmm0
mulsd 0x30(%rbx), %xmm0
leaq 0xbb25(%rip), %rax      # 0x15408
divsd (%rax), %xmm0
jmp 0x98f1
movsd 0xbf97(%rip), %xmm0     # 0x15888
movsd %xmm0, 0x38(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9c25
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x9b9b
movsd 0x30(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x20(%rax), %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x20(%rax)
movsd 0x30(%rax), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x30(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9b76
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movsd 0xbca2(%rip), %xmm0     # 0x15890
andpd 0x441a(%rip), %xmm0     # 0xe010
ucomisd 0x56aa(%rip), %xmm0     # 0xf2a8
jbe 0x9c17
movsd 0x40(%rdi), %xmm0
mulsd 0x30(%rdi), %xmm0
leaq 0xb7f7(%rip), %rax      # 0x15408
divsd (%rax), %xmm0
jmp 0x9c1f
movsd 0xbc69(%rip), %xmm0     # 0x15888
movsd %xmm0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcee9
testq %rax, %rax
je 0x9c6d
movsd 0x38(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x30(%rax), %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x30(%rax)
movsd 0x40(%rax), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x40(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9c48
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x9cb6
movsd 0x38(%rbx), %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd 0x50(%rax), %xmm2
mulpd %xmm1, %xmm2
movupd %xmm2, 0x50(%rax)
movsd 0x60(%rax), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x60(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9c91
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movsd 0xbbc8(%rip), %xmm0     # 0x15888
movapd 0x4348(%rip), %xmm1     # 0xe010
andpd %xmm0, %xmm1
ucomisd 0x55d4(%rip), %xmm1     # 0xf2a8
jbe 0x9ce8
leaq 0xb72b(%rip), %rax      # 0x15408
mulsd (%rax), %xmm0
divsd 0x30(%rdi), %xmm0
jmp 0x9cf0
movsd 0xbba0(%rip), %xmm0     # 0x15890
movsd %xmm0, 0x40(%rdi)
retq