LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/singpolyma[P]mnemonicode/mnemonic.c
// Function: mn_decode
int
mn_decode (char *src, void *dest, int destsize)
{
  mn_index index;
  int offset = 0;
  int status;

  while ((index = mn_next_word_index (&src)) != 0)
    {
      (void) mn_decode_word_index (index, dest, destsize, &offset);
    }
  if (*src != 0)
    return MN_EWORD;
  status = mn_decode_word_index (MN_EOF, dest, destsize, &offset);
  if (status < 0)
    return status;
  return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xb4b0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0xbd80
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x24(%rbp), %rcx
callq 0xb6f0
jmp 0xbd5a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xbd95
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0xbdbe
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %edi, %edi
leaq -0x24(%rbp), %rcx
callq 0xb6f0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0xbdb8
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbdbe
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: FieldMult
unsigned char FieldMult(unsigned char a, unsigned char b)
{
	const unsigned char ReductionPoly = 0x3;
	unsigned char x = a, ret = 0;
	int i;
	for(i = 0; i < 4; i++) {
		if((b>>i)&1) ret ^= x;
		if(x&0x8) {
			x <<= 1;
			x ^= ReductionPoly;
		}
		else x <<= 1;
	}
	return ret&WORDFILTER;
}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rsp)
movb %al, -0x2(%rsp)
movb $0x3, -0x3(%rsp)
movb -0x1(%rsp), %al
movb %al, -0x4(%rsp)
movb $0x0, -0x5(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0x1572
movzbl -0x2(%rsp), %eax
movl -0xc(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1532
movzbl -0x4(%rsp), %ecx
movzbl -0x5(%rsp), %eax
xorl %ecx, %eax
movb %al, -0x5(%rsp)
movzbl -0x4(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1558
movzbl -0x4(%rsp), %eax
shll %eax
movb %al, -0x4(%rsp)
movzbl -0x4(%rsp), %eax
xorl $0x3, %eax
movb %al, -0x4(%rsp)
jmp 0x1563
movzbl -0x4(%rsp), %eax
shll %eax
movb %al, -0x4(%rsp)
jmp 0x1565
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1508
movzbl -0x5(%rsp), %eax
andl $0xf, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: AddKey
void AddKey(unsigned char state[4][4], unsigned char* keyBytes, int half)
{
	int i, j;
	if((half&1) == 0){
		for(i = 0; i < 4; i++)
			for(j = 0; j < 4; j++)
				state[i][j] ^= keyBytes[4*i+j];
	}
	else{
		for(i = 0; i < 4; i++)
			for(j = 0; j < 4; j++)
				state[i][j] ^= keyBytes[4*i+j+(LED>64?16:0)];
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x160f
movl $0x0, -0x18(%rsp)
cmpl $0x4, -0x18(%rsp)
jge 0x160a
movl $0x0, -0x1c(%rsp)
cmpl $0x4, -0x1c(%rsp)
jge 0x15fb
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
shll $0x2, %ecx
addl -0x1c(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rsp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x15b1
jmp 0x15fd
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x15a2
jmp 0x1699
movl $0x0, -0x18(%rsp)
cmpl $0x4, -0x18(%rsp)
jge 0x1697
movl $0x0, -0x1c(%rsp)
cmpl $0x4, -0x1c(%rsp)
jge 0x1688
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
shll $0x2, %ecx
addl -0x1c(%rsp), %ecx
movq 0x39ac(%rip), %rdx      # 0x4ff0
movl (%rdx), %edi
xorl %edx, %edx
movl $0x10, %esi
cmpl $0x40, %edi
cmovgl %esi, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rsp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1626
jmp 0x168a
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x1617
jmp 0x1699
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: AddConstants
void AddConstants(unsigned char state[4][4], int r)
{
	const unsigned char RC[48] = {
		0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3E, 0x3D, 0x3B, 0x37, 0x2F,
		0x1E, 0x3C, 0x39, 0x33, 0x27, 0x0E, 0x1D, 0x3A, 0x35, 0x2B,
		0x16, 0x2C, 0x18, 0x30, 0x21, 0x02, 0x05, 0x0B, 0x17, 0x2E,
		0x1C, 0x38, 0x31, 0x23, 0x06, 0x0D, 0x1B, 0x36, 0x2D, 0x1A,
		0x34, 0x29, 0x12, 0x24, 0x08, 0x11, 0x22, 0x04
	};
    /* row-dependent constants */
	state[1][0] ^= 1;
	state[2][0] ^= 2;
	state[3][0] ^= 3;

    /* key-size dependent constants */
	state[0][0] ^= (LED>>4)&0xf;
	state[1][0] ^= (LED>>4)&0xf;
	state[2][0] ^= LED & 0xf;
	state[3][0] ^= LED & 0xf;

    /* round-dependent constants */
	unsigned char tmp = (RC[r] >> 3) & 7;
	state[0][1] ^= tmp;
	state[2][1] ^= tmp;
	tmp =  RC[r] & 7;
	state[1][1] ^= tmp;
	state[3][1] ^= tmp;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x1977(%rip), %rsi      # 0x3030
movl $0x30, %edx
callq 0x1140
movq 0x50(%rsp), %rax
movzbl 0x4(%rax), %ecx
xorl $0x1, %ecx
movb %cl, 0x4(%rax)
movq 0x50(%rsp), %rax
movzbl 0x8(%rax), %ecx
xorl $0x2, %ecx
movb %cl, 0x8(%rax)
movq 0x50(%rsp), %rax
movzbl 0xc(%rax), %ecx
xorl $0x3, %ecx
movb %cl, 0xc(%rax)
movq 0x38f9(%rip), %rax      # 0x4ff0
movl (%rax), %edx
sarl $0x4, %edx
andl $0xf, %edx
movq 0x50(%rsp), %rax
movzbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
movq 0x38de(%rip), %rax      # 0x4ff0
movl (%rax), %edx
sarl $0x4, %edx
andl $0xf, %edx
movq 0x50(%rsp), %rax
movzbl 0x4(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x4(%rax)
movq 0x38c1(%rip), %rax      # 0x4ff0
movl (%rax), %edx
andl $0xf, %edx
movq 0x50(%rsp), %rax
movzbl 0x8(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x8(%rax)
movq 0x38a7(%rip), %rax      # 0x4ff0
movl (%rax), %edx
andl $0xf, %edx
movq 0x50(%rsp), %rax
movzbl 0xc(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xc(%rax)
movslq 0x4c(%rsp), %rax
movzbl 0x10(%rsp,%rax), %eax
sarl $0x3, %eax
andl $0x7, %eax
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %edx
movq 0x50(%rsp), %rax
movzbl 0x1(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x1(%rax)
movzbl 0xf(%rsp), %edx
movq 0x50(%rsp), %rax
movzbl 0x9(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x9(%rax)
movslq 0x4c(%rsp), %rax
movzbl 0x10(%rsp,%rax), %eax
andl $0x7, %eax
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %edx
movq 0x50(%rsp), %rax
movzbl 0x5(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x5(%rax)
movzbl 0xf(%rsp), %edx
movq 0x50(%rsp), %rax
movzbl 0xd(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xd(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: SubCell
void SubCell(unsigned char state[4][4])
{
	int i,j;
	for(i = 0; i < 4; i++)
		for(j = 0; j <  4; j++)
			state[i][j] = sbox[state[i][j]];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0x185e
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x184f
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
movq 0x37d2(%rip), %rax      # 0x4ff8
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x17fc
jmp 0x1851
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x17ed
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: ShiftRow
void ShiftRow(unsigned char state[4][4])
{
	int i, j;
	unsigned char tmp[4];
	for(i = 1; i < 4; i++) {
		for(j = 0; j < 4; j++)
			tmp[j] = state[i][j];
		for(j = 0; j < 4; j++)
			state[i][j] = tmp[(j+i)%4];
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0x1914
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x18b6
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq -0x10(%rsp), %rax
movb %cl, -0x14(%rsp,%rax)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x1880
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x1902
movl -0x10(%rsp), %eax
addl -0xc(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movb -0x14(%rsp,%rax), %dl
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x18be
jmp 0x1904
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x186d
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: MixColumn
void MixColumn(unsigned char state[4][4])
{
	int i, j, k;
	unsigned char tmp[4];
	for(j = 0; j < 4; j++){
		for(i = 0; i < 4; i++) {
			unsigned char sum = 0;
			for(k = 0; k < 4; k++)
				sum ^= FieldMult(MixColMatrix[i][k], state[k][j]);
			tmp[i] = sum;
		}
		for(i = 0; i < 4; i++)
			state[i][j] = tmp[i];
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x4, 0x18(%rsp)
jge 0x1a28
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x19d8
movb $0x0, 0xf(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x19bb
movslq 0x1c(%rsp), %rcx
movq 0x3661(%rip), %rax      # 0x4fd0
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movzbl %dl, %edi
movzbl (%rax,%rcx), %esi
callq 0x10a0
movzbl %al, %ecx
movzbl 0xf(%rsp), %eax
xorl %ecx, %eax
movb %al, 0xf(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x195c
movb 0xf(%rsp), %cl
movslq 0x1c(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1944
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x1a16
movslq 0x1c(%rsp), %rax
movb 0x10(%rsp,%rax), %dl
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x19e0
jmp 0x1a18
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1931
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/silc.c
// Function: ae_init
int ae_init(ae_cxt* cxt, const byte* userkey, int keylen)
{
	if(keylen != CRYPTO_KEYBYTES){
		return KEY_ERROR;
	}
	cxt->userkey = (byte*)userkey;
	cxt->klen = keylen;

	return SUCCESS;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
cmpl $0xa, -0x1c(%rsp)
je 0x1dbf
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1de1
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/futex2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		unsigned int addr = 0;

		futex(&addr, FUTEX_WAIT, 1, NULL, NULL, 0);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0xca, %edi
leaq -0x14(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
movl $0x0, (%rsp)
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1fb0
// File: /workspace/github_c_makefile_star2_O0/GuiMartinelli[P]so_long_exemplos/movimento.c
// Function: key_input
int	key_input(int key, t_ptr *ptr)
{
	int x;

	x = 0;
	if (key == 'a')
		ptr->c.x -= 20;
	else if (key == 'd')
		ptr->c.x += 20;
	else if (key == 'p')
		exit(1);

	//Destroy imagem atual
	mlx_clear_window(ptr->mlx, ptr->win);

	//Renderiza mapa novamente
	while (x < 10)
	{
		mlx_put_image_to_window(ptr->mlx, ptr->win, ptr->f.ptr, (50 * x), 0);
		x++;
	}
	//Printa player na nova posição
	mlx_put_image_to_window(ptr->mlx, ptr->win, ptr->c.ptr, ptr->c.x, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x61, -0x8(%rbp)
jne 0x64eb
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
subl $0x14, %ecx
movl %ecx, 0x18(%rax)
jmp 0x6514
cmpl $0x64, -0x8(%rbp)
jne 0x6500
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x14, %ecx
movl %ecx, 0x18(%rax)
jmp 0x6512
cmpl $0x70, -0x8(%rbp)
jne 0x6510
movl $0x1, %edi
callq 0x6360
jmp 0x6512
jmp 0x6514
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7090
cmpl $0xa, -0x14(%rbp)
jge 0x655c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
imull $0x32, -0x14(%rbp), %ecx
xorl %r8d, %r8d
callq 0x6f50
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6528
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
xorl %r8d, %r8d
callq 0x6f50
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GuiMartinelli[P]so_long_exemplos/movimento.c
// Function: main
int	main(void)
{
	t_ptr	ptr;
	int	x;
	int	y;

	//Posição inicial do player
	ptr.c.x = 0;
	ptr.c.y = 0;

	ptr.mlx = mlx_init();
	ptr.win = mlx_new_window(ptr.mlx, 500, 50, "test");
	ptr.c.ptr=mlx_xpm_file_to_image(ptr.mlx, "img/img.xpm", &x, &y);
	ptr.f.ptr=mlx_xpm_file_to_image(ptr.mlx, "img/floor.xpm", &x, &y);
	mlx_key_hook(ptr.win, key_input, &ptr);
	mlx_loop(ptr.mlx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x6760
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movl $0x32, %edx
leaq 0x3a3e(%rip), %rcx      # 0xa004
callq 0x6a90
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x3a2f(%rip), %rsi      # 0xa009
leaq -0x34(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x7bb0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x3a1f(%rip), %rsi      # 0xa015
leaq -0x34(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x7bb0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x152(%rip), %rsi      # 0x64c0
leaq -0x30(%rbp), %rdx
callq 0x6d80
movq -0x30(%rbp), %rdi
callq 0x6c10
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/solve.c
// Function: tijdvalkje
void tijdvalkje(const int deKnoop,const matrix A)
{ /* deze functie tekent een nifty tijdvalkje om te kunnen zien of de
   * de software nog ergens mee bezig is...
   */
  float fraction;
  int pos, pos2;
  
  if (deKnoop==0) /* teken het tijdvalkje */
    { /* lengte van de lijn is 65 */
      fprintf(stderr,"\n* Running the solver...\n");
      fprintf(stderr,"=================================================================\n");
      tcurpos = 0;
    }
  else if (deKnoop==-1) /* maak het tijdvalkje af */
    {
      fprintf(stderr,"\n=================================================================\n\n");
    }
  else /* teken het percentage */
    { fraction = (float)((float)deKnoop/(float)A->rows);
    fraction = (float)sqrt((double)fraction);
    pos = (int)((fraction)*(float)65.0);
    if (pos>tcurpos) {
      pos2 = 0;
      while (pos2<pos)
	{ fprintf(stderr,">");
	pos2++;
	}
      fprintf(stderr,"\r"); 
    }
    tcurpos=pos;
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x12c3
movq 0x1cd6d(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x17d8b(%rip), %rsi     # 0x19020
movb $0x0, %al
callq 0x10d0
movq 0x1cd55(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x18d34(%rip), %rsi     # 0x19fe1
movb $0x0, %al
callq 0x10d0
movl $0x0, 0x1d116(%rip)     # 0x1e3d4
jmp 0x1396
cmpl $-0x1, 0x24(%rsp)
jne 0x12e7
movq 0x1cd27(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x17d5f(%rip), %rsi     # 0x1903a
movb $0x0, %al
callq 0x10d0
jmp 0x1394
cvtsi2ssl 0x24(%rsp), %xmm0
movq 0x18(%rsp), %rax
cvtsi2ssl (%rax), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1150
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x17ce3(%rip), %xmm0    # 0x19004
mulss 0x14(%rsp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1d09b(%rip), %eax     # 0x1e3d4
jle 0x138a
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x1372
movq 0x1cca4(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x17d21(%rip), %rsi     # 0x1907f
movb $0x0, %al
callq 0x10d0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1343
movq 0x1cc7f(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x17cfe(%rip), %rsi     # 0x19081
movb $0x0, %al
callq 0x10d0
movl 0x10(%rsp), %eax
movl %eax, 0x1d040(%rip)     # 0x1e3d4
jmp 0x1396
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: write_elements
void write_elements(const element elist )
{ element e;
  printf("\n{---------------------------------------------------------------}\n");
  printf("{ POST output of the element connectivity.\n");
  printf("  format:\n");
  printf("  element_label node_1_label node_2_label node_3_label\n");
  printf("}\n");
  printf("elements TRIL\n");

  e=(element)element_dll(elist,START,0);
  while(e!=(element)NULL)
  { printf(" %3d %3d %3d %3d\n",e->label,e->p1,e->p2,e->p3);
	e=e->NEXT;
  } 

  printf("end_elements\n\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x15320(%rip), %rdi     # 0x19460
movb $0x0, %al
callq 0x1070
leaq 0x15356(%rip), %rdi     # 0x194a4
movb $0x0, %al
callq 0x1070
leaq 0x15374(%rip), %rdi     # 0x194d0
movb $0x0, %al
callq 0x1070
leaq 0x15371(%rip), %rdi     # 0x194db
movb $0x0, %al
callq 0x1070
leaq 0x15329(%rip), %rdi     # 0x194a1
movb $0x0, %al
callq 0x1070
leaq 0x1538d(%rip), %rdi     # 0x19513
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x14570
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x41e7
movq 0x8(%rsp), %rax
movl 0x14(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %edx
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %ecx
movq 0x8(%rsp), %rax
movl 0x20(%rax), %r8d
leaq 0x15352(%rip), %rdi     # 0x19522
movb $0x0, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x41a0
leaq 0x15346(%rip), %rdi     # 0x19534
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: write_node_displacements
void write_node_displacements(point plist)
{ point p; 
  printf("\n{---------------------------------------------------------------}\n");
  printf("{ POST output of the node displacements.\n");
  printf("  format:\n");
  printf("  node_label displacement_x displacement_y displacement_z\n");
  printf("}\n");
  printf("node_displacements\n");

  p=(point)point_dll(plist,START,0);
  while (p!=(point)NULL)
  { printf(" %3d  % 5.8E  % 5.8E  % 5.8E \n",p->label, p->dx, p->dy, p->dz );
    p=p->NEXT;
  }

  printf("end_node_displacements\n\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x15250(%rip), %rdi     # 0x19460
movb $0x0, %al
callq 0x1070
leaq 0x15325(%rip), %rdi     # 0x19543
movb $0x0, %al
callq 0x1070
leaq 0x152a4(%rip), %rdi     # 0x194d0
movb $0x0, %al
callq 0x1070
leaq 0x15333(%rip), %rdi     # 0x1956d
movb $0x0, %al
callq 0x1070
leaq 0x15259(%rip), %rdi     # 0x194a1
movb $0x0, %al
callq 0x1070
leaq 0x153e3(%rip), %rdi     # 0x19639
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x42bc
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rax
movsd 0x50(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x58(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x60(%rax), %xmm2
leaq 0x15303(%rip), %rdi     # 0x195a8
movb $0x3, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4270
leaq 0x15304(%rip), %rdi     # 0x195c7
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: write_total_node_displacements
void write_total_node_displacements(const point plist)
{ point p; 
  printf("\n{---------------------------------------------------------------}\n");
  printf("{ POST output of the total node displacements.\n");
  printf("  format:\n");
  printf("  node_label displacement_modulus\n");
  printf("}\n");
  printf("total_node_displacements\n");

  p=(point)point_dll(plist,START,0);
  while (p!=(point)NULL)
  { printf(" %3d  % 5.8E  % 5.8E  % 5.8E \n",p->label, p->dx+p->x, p->dy+p->y, p->dz+p->z );
	p=p->NEXT;
  }

  printf("end_total_node_displacements\n\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x15180(%rip), %rdi     # 0x19460
movb $0x0, %al
callq 0x1070
leaq 0x152f2(%rip), %rdi     # 0x195e0
movb $0x0, %al
callq 0x1070
leaq 0x151d4(%rip), %rdi     # 0x194d0
movb $0x0, %al
callq 0x1070
leaq 0x15306(%rip), %rdi     # 0x19610
movb $0x0, %al
callq 0x1070
leaq 0x15189(%rip), %rdi     # 0x194a1
movb $0x0, %al
callq 0x1070
leaq 0x1530d(%rip), %rdi     # 0x19633
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x43aa
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rax
movsd 0x50(%rax), %xmm0
movq 0x8(%rsp), %rax
addsd 0x20(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x58(%rax), %xmm1
movq 0x8(%rsp), %rax
addsd 0x28(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x60(%rax), %xmm2
movq 0x8(%rsp), %rax
addsd 0x30(%rax), %xmm2
leaq 0x15215(%rip), %rdi     # 0x195a8
movb $0x3, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4340
leaq 0x1529c(%rip), %rdi     # 0x1964d
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: write_node_tractions
void write_node_tractions(const point plist)
{ point p; 
  printf("\n{---------------------------------------------------------------}\n");
  printf("{ POST output of the node tractions.\n");
  printf("  format:\n");
  printf("  node_label traction_x traction_y traction_z\n");
  printf("}\n");
  printf("node_tractions\n");

  p=(point)point_dll(plist,START,0);
  while (p!=(point)NULL)
  { printf(" %3d  % 5.8E  % 5.8E  % 5.8E \n",p->label, p->fx, p->fy, p->fz );
	p=p->NEXT;
  }

  printf("end_node_tractions\n\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x15090(%rip), %rdi     # 0x19460
movb $0x0, %al
callq 0x1070
leaq 0x1528e(%rip), %rdi     # 0x1966c
movb $0x0, %al
callq 0x1070
leaq 0x150e4(%rip), %rdi     # 0x194d0
movb $0x0, %al
callq 0x1070
leaq 0x15298(%rip), %rdi     # 0x19692
movb $0x0, %al
callq 0x1070
leaq 0x15099(%rip), %rdi     # 0x194a1
movb $0x0, %al
callq 0x1070
leaq 0x1550e(%rip), %rdi     # 0x19924
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x447c
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x40(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm2
leaq 0x15143(%rip), %rdi     # 0x195a8
movb $0x3, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4430
leaq 0x1523e(%rip), %rdi     # 0x196c1
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: write_contact_node_tractions
void write_contact_node_tractions(const point plist)
{ point p; 
  printf("\n{---------------------------------------------------------------}\n");
  printf("{ POST output of the contact node tractions.\n");
  printf("  format:\n");
  printf("  node_label traction_x traction_y traction_z\n");
  printf("}\n");
  printf("contact_node_tractions\n");

  p=(point)point_dll(plist,START,0);
  while (p!=(point)NULL)
  { if (p->type==CNODE)
        printf(" %3d  % 5.8E  % 5.8E  % 5.8E, y:% 5.8E \n",p->label, p->fx, p->fy, p->fz,p->y );
    p=p->NEXT;
  }

  printf("end_contact_node_tractions\n\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x140b0(%rip), %rdi     # 0x19460
movb $0x0, %al
callq 0x1070
leaq 0x14530(%rip), %rdi     # 0x198ee
movb $0x0, %al
callq 0x1070
leaq 0x14104(%rip), %rdi     # 0x194d0
movb $0x0, %al
callq 0x1070
leaq 0x142b8(%rip), %rdi     # 0x19692
movb $0x0, %al
callq 0x1070
leaq 0x140b9(%rip), %rdi     # 0x194a1
movb $0x0, %al
callq 0x1070
leaq 0x14526(%rip), %rdi     # 0x1991c
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5471
movq 0x8(%rsp), %rax
cmpl $0xf, 0x14(%rax)
jne 0x5461
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x40(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm2
movq 0x8(%rsp), %rax
movsd 0x28(%rax), %xmm3
leaq 0x144da(%rip), %rdi     # 0x19934
movb $0x4, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x5410
leaq 0x144e5(%rip), %rdi     # 0x1995d
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: cnodesonelement
int cnodesonelement(element e, mesh m)
{ point p;
  int cnodes=0;
  p=(point)point_dll(m->mesh_p,SEARCH,e->p1);
    if (p->type==CNODE) cnodes++;
  p=(point)point_dll(m->mesh_p,SEARCH,e->p2);
    if (p->type==CNODE) cnodes++;
  p=(point)point_dll(m->mesh_p,SEARCH,e->p3);
    if (p->type==CNODE) cnodes++;
  return cnodes;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %edx
movl $0x2, %esi
callq 0x175c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xf, 0x14(%rax)
jne 0x54db
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl 0x1c(%rax), %edx
movl $0x2, %esi
callq 0x175c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xf, 0x14(%rax)
jne 0x5510
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl 0x20(%rax), %edx
movl $0x2, %esi
callq 0x175c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xf, 0x14(%rax)
jne 0x5545
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: edgeelementsonnode
int edgeelementsonnode(point p, mesh m)
{ int edges=0;
  element e;
  int cnodes;
  e=(element)element_dll(m->mesh_e,START,0);
  while (e!=(element)NULL)
  { cnodes = cnodesonelement(e,m);
    if ( cnodes==2)  
    { if ( (e->p1==p->label)||(e->p2==p->label)||(e->p3==p->label) )
      { edges++; 
      }
    }
    e=e->NEXT;
  }
  return edges;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x14570
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x55f2
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5490
movl %eax, 0x4(%rsp)
cmpl $0x2, 0x4(%rsp)
jne 0x55e2
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x10(%rcx), %eax
je 0x55d5
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x10(%rcx), %eax
je 0x55d5
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x55e0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x55e2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x557d
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/emath/post.c
// Function: elforce
void elforce(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)*e->area*theMesh->G_SCALE;
        *fy= 1.0/3.0*(t1y+t2y+t3y)*e->area*theMesh->G_SCALE;
        *fz= 1.0/3.0*(t1z+t2z+t3z)*e->area*theMesh->G_SCALE;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq 0x70(%rsp), %rax
movl 0x18(%rax), %edx
movl $0x2, %esi
callq 0x175c0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x48(%rsp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x48(%rsp), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq 0x70(%rsp), %rax
movl 0x1c(%rax), %edx
movl $0x2, %esi
callq 0x175c0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq 0x70(%rsp), %rax
movl 0x20(%rax), %edx
movl $0x2, %esi
callq 0x175c0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x40(%rsp), %xmm1
addsd 0x28(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
movsd 0x13cfd(%rip), %xmm0    # 0x19420
mulsd %xmm1, %xmm0
movq 0x70(%rsp), %rax
mulsd 0xb8(%rax), %xmm0
movq 0x50(%rsp), %rax
mulsd 0x30(%rax), %xmm0
movq 0x68(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x38(%rsp), %xmm1
addsd 0x20(%rsp), %xmm1
addsd 0x8(%rsp), %xmm1
movsd 0x13cbf(%rip), %xmm0    # 0x19420
mulsd %xmm1, %xmm0
movq 0x70(%rsp), %rax
mulsd 0xb8(%rax), %xmm0
movq 0x50(%rsp), %rax
mulsd 0x30(%rax), %xmm0
movq 0x60(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x30(%rsp), %xmm1
addsd 0x18(%rsp), %xmm1
addsd (%rsp), %xmm1
movsd 0x13c82(%rip), %xmm0    # 0x19420
mulsd %xmm1, %xmm0
movq 0x70(%rsp), %rax
mulsd 0xb8(%rax), %xmm0
movq 0x50(%rsp), %rax
mulsd 0x30(%rax), %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x121c0(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
leaq 0x1237a(%rip), %rdi     # 0x19bc8
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x78d2
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movl 0x4(%rsp), %edx
leaq 0x12341(%rip), %rdi     # 0x19bd0
movb $0x0, %al
callq 0x1070
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x28(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x30(%rax), %xmm2
leaq 0x12333(%rip), %rdi     # 0x19bee
movb $0x3, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x7868
leaq 0x12127(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x7, 0x14(%rsp)
leaq 0x120f8(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
leaq 0x122f5(%rip), %rdi     # 0x19c0b
movb $0x0, %al
callq 0x1070
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x14570
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x79aa
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rax), %esi
movl 0x14(%rsp), %r9d
leaq 0x122bb(%rip), %rdi     # 0x19c13
movl $0x5b, %edx
movl $0x1, %r8d
movl %r8d, %ecx
movl $0x3, (%rsp)
movb $0x0, %al
callq 0x1070
movq 0x18(%rsp), %rax
movl 0x18(%rax), %esi
movq 0x18(%rsp), %rax
movl 0x20(%rax), %edx
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %ecx
leaq 0x1228c(%rip), %rdi     # 0x19c1f
movb $0x0, %al
callq 0x1070
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x7930
leaq 0x1204f(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x12030(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
leaq 0x1202a(%rip), %rdi     # 0x19a08
movb $0x0, %al
callq 0x1070
leaq 0x120ee(%rip), %rdi     # 0x19ada
movb $0x0, %al
callq 0x1070
leaq 0x12233(%rip), %rdi     # 0x19c2d
movb $0x0, %al
callq 0x1070
leaq 0x120d2(%rip), %rdi     # 0x19ada
movb $0x0, %al
callq 0x1070
leaq 0x12027(%rip), %rdi     # 0x19a3d
movb $0x0, %al
callq 0x1070
leaq 0x12031(%rip), %rdi     # 0x19a55
movb $0x0, %al
callq 0x1070
leaq 0x12035(%rip), %rdi     # 0x19a67
movb $0x0, %al
callq 0x1070
leaq 0x12033(%rip), %rdi     # 0x19a73
movb $0x0, %al
callq 0x1070
leaq 0x12054(%rip), %rdi     # 0x19aa2
movb $0x0, %al
callq 0x1070
leaq 0x121e7(%rip), %rdi     # 0x19c43
movb $0x0, %al
callq 0x1070
leaq 0x1207c(%rip), %rdi     # 0x19ae6
movb $0x0, %al
callq 0x1070
leaq 0x120ab(%rip), %rdi     # 0x19b23
movb $0x0, %al
callq 0x1070
leaq 0x120b3(%rip), %rdi     # 0x19b39
movb $0x0, %al
callq 0x1070
leaq 0x120bb(%rip), %rdi     # 0x19b4f
movb $0x0, %al
callq 0x1070
leaq 0x1220e(%rip), %rdi     # 0x19cb0
movb $0x0, %al
callq 0x1070
leaq 0x1209f(%rip), %rdi     # 0x19b4f
movb $0x0, %al
callq 0x1070
leaq 0x121f2(%rip), %rdi     # 0x19cb0
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7b32
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
leaq 0x120f9(%rip), %rdi     # 0x19be8
movb $0x0, %al
callq 0x1070
movq 0x8(%rsp), %rax
movsd 0x50(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x58(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x60(%rax), %xmm2
leaq 0x12166(%rip), %rdi     # 0x19c81
movb $0x3, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x7ad8
leaq 0x11ec7(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x11ea0(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
leaq 0x11e9a(%rip), %rdi     # 0x19a08
movb $0x0, %al
callq 0x1070
leaq 0x11eb5(%rip), %rdi     # 0x19a31
movb $0x0, %al
callq 0x1070
leaq 0x12135(%rip), %rdi     # 0x19cbf
movb $0x0, %al
callq 0x1070
leaq 0x11f42(%rip), %rdi     # 0x19ada
movb $0x0, %al
callq 0x1070
leaq 0x11e97(%rip), %rdi     # 0x19a3d
movb $0x0, %al
callq 0x1070
leaq 0x11ea1(%rip), %rdi     # 0x19a55
movb $0x0, %al
callq 0x1070
leaq 0x11ea5(%rip), %rdi     # 0x19a67
movb $0x0, %al
callq 0x1070
leaq 0x11ea3(%rip), %rdi     # 0x19a73
movb $0x0, %al
callq 0x1070
leaq 0x11ec4(%rip), %rdi     # 0x19aa2
movb $0x0, %al
callq 0x1070
leaq 0x12057(%rip), %rdi     # 0x19c43
movb $0x0, %al
callq 0x1070
leaq 0x11eec(%rip), %rdi     # 0x19ae6
movb $0x0, %al
callq 0x1070
leaq 0x11f1b(%rip), %rdi     # 0x19b23
movb $0x0, %al
callq 0x1070
leaq 0x11f23(%rip), %rdi     # 0x19b39
movb $0x0, %al
callq 0x1070
leaq 0x11f2b(%rip), %rdi     # 0x19b4f
movb $0x0, %al
callq 0x1070
leaq 0x1207e(%rip), %rdi     # 0x19cb0
movb $0x0, %al
callq 0x1070
leaq 0x11f0f(%rip), %rdi     # 0x19b4f
movb $0x0, %al
callq 0x1070
leaq 0x12062(%rip), %rdi     # 0x19cb0
movb $0x0, %al
callq 0x1070
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x175c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7cc2
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
leaq 0x11f69(%rip), %rdi     # 0x19be8
movb $0x0, %al
callq 0x1070
movq 0x8(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x40(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm2
leaq 0x11fd6(%rip), %rdi     # 0x19c81
movb $0x3, %al
callq 0x1070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x7c68
leaq 0x11d37(%rip), %rdi     # 0x19a00
movb $0x0, %al
callq 0x1070
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x1080
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rdi
callq 0x10e0
cmpl $0x0, %eax
je 0x8f27
movl $0x20, 0x14(%rsp)
jmp 0x8f6d
movsbl 0x7(%rsp), %eax
cmpl $0x7b, %eax
jne 0x8f3a
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x7d, %eax
jne 0x8f4d
movl (%rsp), %eax
addl $-0x1, %eax
movl %eax, (%rsp)
jmp 0x8f4f
cmpl $0x0, (%rsp)
jne 0x8f00
movsbl 0x7(%rsp), %eax
cmpl $0x7d, %eax
jne 0x8f64
movb $0x20, 0x7(%rsp)
movsbl 0x7(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x8ef0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10e0
cmpl $0x0, %eax
je 0x8fda
movq 0x8(%rsp), %rax
movb $0x45, (%rax)
movq 0x8(%rsp), %rax
movb $0x4e, 0x1(%rax)
movq 0x8(%rsp), %rax
movb $0x44, 0x2(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x3(%rax)
jmp 0x9077
jmp 0x8fdc
callq 0x1160
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x8f95
jmp 0x8ff9
callq 0x1160
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x901d
jmp 0x906a
movl 0x4(%rsp), %edi
callq 0x1040
movb %al, %dl
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x4f, (%rsp)
jle 0x9053
movl $0x1, %edi
movl $0x3a, %esi
callq 0x15200
movq 0x10(%rsp), %rdi
callq 0x8ef0
movl %eax, %edi
callq 0x1040
movl %eax, 0x4(%rsp)
jmp 0x8ff9
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x15396(%rip), %rsi     # 0x1e430
callq 0x8f80
leaq 0x1538a(%rip), %rdi     # 0x1e430
leaq 0x10e63(%rip), %rsi     # 0x19f10
callq 0x10c0
cmpl $0x0, %eax
jne 0x90bc
addq $0x18, %rsp
retq
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x175c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
leaq 0x1534e(%rip), %rdi     # 0x1e430
callq 0x1130
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rdi
leaq 0x15330(%rip), %rsi     # 0x1e430
callq 0x8f80
leaq 0x15324(%rip), %rdi     # 0x1e430
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, 0x20(%rax)
movq 0x10(%rsp), %rdi
leaq 0x15302(%rip), %rsi     # 0x1e430
callq 0x8f80
leaq 0x152f6(%rip), %rdi     # 0x1e430
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, 0x28(%rax)
movq 0x10(%rsp), %rdi
leaq 0x152d4(%rip), %rsi     # 0x1e430
callq 0x8f80
leaq 0x152c8(%rip), %rdi     # 0x1e430
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl $0xb, 0x14(%rax)
jmp 0x908e
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
leaq 0x15258(%rip), %rax     # 0x1e404
movl $0x1, (%rax)
movq (%rsp), %rdi
leaq 0x152c3(%rip), %rsi     # 0x1e480
callq 0x8f80
leaq 0x152b7(%rip), %rdi     # 0x1e480
leaq 0x10d4a(%rip), %rsi     # 0x19f1a
callq 0x10c0
cmpl $0x0, %eax
jne 0x91dc
popq %rax
retq
jmp 0x91b2
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x152ce(%rip), %rsi     # 0x1e4d0
callq 0x8f80
leaq 0x152c2(%rip), %rdi     # 0x1e4d0
leaq 0x10d05(%rip), %rsi     # 0x19f1a
callq 0x10c0
cmpl $0x0, %eax
jne 0x9224
addq $0x18, %rsp
retq
leaq 0x152a5(%rip), %rdi     # 0x1e4d0
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rsp), %rdi
leaq 0x1526f(%rip), %rsi     # 0x1e4d0
callq 0x8f80
leaq 0x15263(%rip), %rdi     # 0x1e4d0
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rsp), %rdi
leaq 0x1522d(%rip), %rsi     # 0x1e4d0
callq 0x8f80
leaq 0x15221(%rip), %rdi     # 0x1e4d0
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x91f6
nop