LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/sound_device/UARTRecord.c
// Function: int_handler
void int_handler(){

	fprintf(stderr, "Interrupt received\n");

	if(UART_is_open(&uart))
		UART_close(&uart);

	exit(0);

}

// Assembly:
pushq %rax
movq 0x2c64(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xc66(%rip), %rdi       # 0x2004
movl $0x13, %esi
movl $0x1, %edx
callq 0x1130
leaq 0x2e08(%rip), %rdi      # 0x41bc
callq 0x17b6
testb %al, %al
je 0x13c9
leaq 0x2df8(%rip), %rdi      # 0x41bc
callq 0x17bd
xorl %edi, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/io/uart/UART.c
// Function: UART_close
int UART_close(UART *self){

	// Ensure any custom baud rate is reset to the normal speed
	struct serial_struct ss;
	ioctl(self->fd, TIOCGSERIAL, &ss);
	ss.flags &= ~ASYNC_SPD_MASK;
	ioctl(self->fd, TIOCSSERIAL, &ss);

	int status = close(self->fd);
	if(status == -1){
		perror("Unable to close socket");
		return -1;
	}

	self->fd = -1;

	return 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movl (%rdi), %edi
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
movl $0x541e, %esi           # imm = 0x541E
movq %r15, %rdx
xorl %eax, %eax
callq 0x1050
andl $0xffffefcf, 0x10(%r15) # imm = 0xFFFFEFCF
movl (%r14), %edi
movl $0x541f, %esi           # imm = 0x541F
movq %r15, %rdx
xorl %eax, %eax
callq 0x1050
movl (%r14), %edi
callq 0x1060
cmpl $-0x1, %eax
je 0x181b
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x951(%rip), %rdi       # 0x2173
callq 0x1100
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x180f
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/io/uart/UART.c
// Function: UART_write
int UART_write(UART *self, char *buffer, int length){

	int bytes_written = write(self->fd, buffer, length);
	if(bytes_written != length){
		perror("Did not write length bytes");
		return -1;
	}

	return 0;

}

// Assembly:
pushq %rbx
movl (%rdi), %edi
movslq %edx, %rbx
movq %rbx, %rdx
callq 0x1030
movq %rax, %rcx
xorl %eax, %eax
cmpl %ebx, %ecx
jne 0x1851
popq %rbx
retq
leaq 0x932(%rip), %rdi       # 0x218a
callq 0x1100
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x184f
// File: /workspace/github_c_makefile_star2_O3/singpolyma[P]mnemonicode/mndecode.c
// Function: main
int main(int argc, char **argv) {
	char buf[0x90000];
	mn_byte outbuf[0x10000];
	int buflen;
	int n, i;
	int hex_encoded_output = 0;

	if(argc > 1 && strcmp(argv[1],"-x") == 0) {
		hex_encoded_output = 1;
	}

	buflen = fread(buf, 1, sizeof buf - 1, stdin);
	buf[buflen] = 0;

	n = mn_decode(buf, outbuf, sizeof outbuf);
	if(n < 0) {
		fprintf(stderr, "mn_decode result %d\n", n);
		return EXIT_FAILURE;
	}

	if(hex_encoded_output) {
		for(i = 0; i < n; i++) {
			printf("%02X", outbuf[i]);
		}
	} else {
		fwrite(outbuf, 1, n, stdout);
	}

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0000, %rsp          # imm = 0xA0000
movb $0x1, %bpl
cmpl $0x2, %edi
jl 0xb1ba
movq 0x8(%rsi), %rax
cmpb $0x2d, (%rax)
jne 0xb1ba
cmpb $0x78, 0x1(%rax)
jne 0xb1ba
cmpb $0x0, 0x2(%rax)
setne %bpl
movq 0x4e17(%rip), %rax      # 0xffd8
movq (%rax), %rcx
leaq 0x10000(%rsp), %rbx
movl $0x1, %esi
movl $0x8ffff, %edx          # imm = 0x8FFFF
movq %rbx, %rdi
callq 0xb030
cltq
movb $0x0, 0x10000(%rsp,%rax)
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x10000, %edx          # imm = 0x10000
callq 0xb7f0
testl %eax, %eax
js 0xb25c
testb %bpl, %bpl
je 0xb21c
movl %eax, %edx
movq 0x4dc6(%rip), %rax      # 0xffd0
movq (%rax), %rcx
movq %rsp, %rdi
movl $0x1, %esi
callq 0xb070
jmp 0xb248
testl %eax, %eax
je 0xb248
movl %eax, %r15d
xorl %ebx, %ebx
leaq 0xded(%rip), %r14       # 0xc019
xorl %r12d, %r12d
movzbl (%rsp,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0xb040
incq %r12
cmpq %r12, %r15
jne 0xb22f
jmp 0xb24a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xa0000, %rsp          # imm = 0xA0000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4d95(%rip), %rcx      # 0xfff8
movq (%rcx), %rdi
leaq 0xd97(%rip), %rsi       # 0xc004
movl %eax, %edx
xorl %eax, %eax
callq 0xb060
movl $0x1, %ebx
jmp 0xb24a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/singpolyma[P]mnemonicode/mnemonic.c
// Function: mn_encode_word_index
mn_index mn_encode_word_index (void *vsrc, int srcsize, int n)
{
  mn_word32 x = 0;		/* Temporary for MN_BASE arithmetic */
  int offset;			/* Offset into src */
  int remaining;		/* Octets remaining to end of src */
  int extra = 0;		/* Index 7 extra words for 24 bit data */
  int i;
  mn_byte *src = vsrc;

  if (n < 0 || n >= mn_words_required (srcsize))
    return 0;			/* word out of range */
  offset = (n / 3) * 4;		/* byte offset into src */
  remaining = srcsize - offset;
  if (remaining <= 0)
    return 0;
  if (remaining >= 4)
    remaining = 4;
  for (i = 0; i < remaining; i++)
    x |= (unsigned long)src[offset + i] << (i * 8);	/* endianness-agnostic */

  switch (n % 3)
    {
    case 2:			/* Third word of group */
      if (remaining == 3)	/*  special case for 24 bits */
	extra = MN_BASE;	/*  use one of the 7 3-letter words */
      x /= (MN_BASE * MN_BASE);
      break;
    case 1:			/* Second word of group */
      x /= MN_BASE;
    }
  return x % MN_BASE + extra + 1;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
js 0xb37a
leal (%rsi,%rsi,2), %ecx
addl $0x3, %ecx
leal (%rsi,%rsi,2), %r8d
addl $0x6, %r8d
testl %ecx, %ecx
cmovnsl %ecx, %r8d
sarl $0x2, %r8d
cmpl %edx, %r8d
jle 0xb37a
movl %edx, %ecx
movl $0xaaaaaaab, %r8d       # imm = 0xAAAAAAAB
imulq %rcx, %r8
shrq $0x21, %r8
leaq (,%r8,4), %rcx
subl %ecx, %esi
jle 0xb37a
leal (%r8,%r8,2), %eax
subl %eax, %edx
cmpl $0x4, %esi
movl $0x4, %eax
cmovbl %esi, %eax
addq %rcx, %rdi
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r8d, %r8d
movzbl (%rdi,%r9), %r10d
shlq %cl, %r10
orq %r10, %r8
incq %r9
addq $0x8, %rcx
cmpq %r9, %rax
jne 0xb2fc
movabsq $-0x5ec7a2cb6a1d9959, %rcx # imm = 0xA1385D3495E266A7
cmpl $0x1, %edx
je 0xb352
cmpl $0x2, %edx
jne 0xb35f
xorl %eax, %eax
cmpl $0x3, %esi
movl $0x65a, %esi            # imm = 0x65A
cmovneq %rax, %rsi
shrq $0x2, %r8
movabsq $0x32c3f8d286bbcbf, %rdx # imm = 0x32C3F8D286BBCBF
movq %r8, %rax
mulq %rdx
movq %rdx, %r8
shrq $0xd, %r8
jmp 0xb361
movq %r8, %rax
mulq %rcx
movq %rdx, %r8
shrq $0xa, %r8
xorl %esi, %esi
movq %r8, %rax
mulq %rcx
shrq $0xa, %rdx
imull $0x65a, %edx, %eax      # imm = 0x65A
subl %eax, %r8d
leal (%r8,%rsi), %eax
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O3/singpolyma[P]mnemonicode/mnemonic.c
// Function: mn_next_word_index
mn_index
mn_next_word_index (char **ptr)
{
  char *wordstart;
  char wordbuf[MN_WORD_BUFLEN];
  int i = 0;
  char c;
  mn_index idx;

  while (**ptr && !isalpha (**ptr))	/* skip separator chars */
    (*ptr)++;
  wordstart = *ptr;		/* save for error reporting */
  while (**ptr && isalpha (**ptr) && i < MN_WORD_BUFLEN - 1)
    {
      c = *(*ptr)++;
      if (c >= 'A' && c <= 'Z')
	c += 'a' - 'A';		/* convert to lowercase */
      wordbuf[i++] = c;
    }
  wordbuf[i] = '\0';
  while (**ptr && isalpha (**ptr))	/* skip tail of long words */
    (*ptr)++;
  while (**ptr && !isalpha (**ptr))	/* skip separators */
    (*ptr)++;

  if (wordbuf[0] == '\0')
    return 0;			/* EOF, no word found */

  for (idx = 1; idx <= MN_WORDS; idx++)
    {
      if (!strcmp (wordbuf, mn_words[idx]))
	return idx;
      /* FIXME: some fancy code should go here
         to accept misspellings and soundalikes.
         (replacing the linear search would also be nice) */
    }
  *ptr = wordstart;
  return 0;			/* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movb (%r15), %bpl
testb %bpl, %bpl
je 0xb3dd
callq 0xb080
incq %r15
movq %r15, %r14
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
jne 0xb3e4
movq %r14, (%rbx)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0xb3b7
decq %r14
xorl %eax, %eax
movq %r14, %r15
jmp 0xb44a
xorl %eax, %eax
movq %r15, %r14
jmp 0xb44a
callq 0xb080
leaq -0x1(%r14), %r15
xorl %ecx, %ecx
movq (%rax), %rdx
movsbq %bpl, %rsi
testb $0x4, 0x1(%rdx,%rsi,2)
je 0xb442
cmpq $0x17, %rcx
ja 0xb442
leaq (%r14,%rcx), %rdx
movq %rdx, (%rbx)
movzbl -0x1(%r14,%rcx), %edx
leal -0x41(%rdx), %esi
movl %edx, %edi
orb $0x20, %dil
cmpb $0x1a, %sil
movzbl %dil, %esi
cmovael %edx, %esi
leaq 0x1(%rcx), %rdx
movb %sil, (%rsp,%rcx)
movb (%r14,%rcx), %bpl
movq %rdx, %rcx
testb %bpl, %bpl
jne 0xb3ef
addq %rdx, %r14
decq %r14
movl %edx, %ecx
jmp 0xb448
addq %rcx, %r14
decq %r14
movl %ecx, %eax
movb $0x0, (%rsp,%rax)
movb (%r14), %bpl
testb %bpl, %bpl
je 0xb49d
callq 0xb080
incq %r14
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
je 0xb47c
movq %r14, (%rbx)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0xb45e
jmp 0xb49d
callq 0xb080
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
jne 0xb49d
movq %r14, (%rbx)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0xb481
xorl %ebp, %ebp
cmpb $0x0, (%rsp)
je 0xb4da
movl $0x1, %r12d
leaq 0x4bbe(%rip), %r13      # 0x10070
movq %rsp, %r14
movq (%r13,%r12,8), %rsi
movq %r14, %rdi
callq 0xb050
testl %eax, %eax
je 0xb4d7
incq %r12
cmpq $0x662, %r12            # imm = 0x662
jne 0xb4b5
movq %r15, (%rbx)
jmp 0xb4da
movl %r12d, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
movl $0x0, 0xc(%rsp)
movq %rax, %rdi
callq 0xb390
testl %eax, %eax
je 0xb841
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
movl %eax, %edi
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0xb4eb
movq %r12, %rdi
callq 0xb390
testl %eax, %eax
jne 0xb826
movq 0x10(%rsp), %rcx
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
cmpb $0x0, (%rcx)
jne 0xb869
leaq 0xc(%rsp), %rcx
xorl %edi, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb4eb
testl %eax, %eax
js 0xb869
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x2bec(%rip), %rax      # 0x3ff0
movb (%rax), %cl
shrb $0x4, %cl
xorb %cl, (%rdi)
movb (%rax), %al
movl %eax, %ecx
shrb $0x4, %cl
xorb 0x4(%rdi), %cl
xorb $0x1, %cl
movb %cl, 0x4(%rdi)
andb $0xf, %al
movb 0x8(%rdi), %cl
xorb %al, %cl
xorb $0x2, %cl
movb %cl, 0x8(%rdi)
xorb 0xc(%rdi), %al
xorb $0x3, %al
movb %al, 0xc(%rdi)
movslq %esi, %rax
leaq 0xc06(%rip), %rcx       # 0x2040
movb (%rax,%rcx), %al
movl %eax, %ecx
shrb $0x3, %cl
andb $0x7, %cl
xorb %cl, 0x1(%rdi)
xorb %cl, 0x9(%rdi)
andb $0x7, %al
xorb %al, 0x5(%rdi)
xorb %al, 0xd(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %eax, %eax
movq 0x2af9(%rip), %rcx      # 0x3fd0
movq %rdi, %rdx
xorl %esi, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
leaq (,%r8,4), %r10
xorl %r11d, %r11d
leaq (%r10,%rcx), %rbx
movb (%r9,%rbx), %r15b
leaq (%rdi,%r9,4), %rbx
movzbl (%rsi,%rbx), %ebp
xorl %r14d, %r14d
xorl %ebx, %ebx
btl %r14d, %ebp
movzbl %r15b, %r15d
movl %r15d, %r12d
cmovael %eax, %r12d
xorb %r12b, %bl
leal (%r15,%r15), %r12d
movzbl %r12b, %r13d
xorb $0x3, %r12b
testb $0x8, %r15b
movzbl %r12b, %r15d
cmovel %r13d, %r15d
incl %r14d
cmpl $0x4, %r14d
jne 0x1502
andb $0xf, %bl
xorb %bl, %r11b
incq %r9
cmpq $0x4, %r9
jne 0x14ed
movb %r11b, -0x4(%rsp,%r8)
incq %r8
cmpq $0x4, %r8
jne 0x14df
xorl %r8d, %r8d
movb -0x4(%rsp,%r8), %r9b
movb %r9b, (%rdx,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x1555
incq %rsi
incq %rdx
cmpq $0x4, %rsi
jne 0x14dc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/silc.c
// Function: process_ad
int process_ad(ae_cxt* cxt, const byte* ad, unsigned long long adlen, const byte* nonce, unsigned long long nlen)
{
	byte* state = cxt->es;

	cxt->ad = (byte*) ad;
	cxt->adlen = adlen;
	cxt->nonce = (byte*) nonce;
	cxt->nlen = nlen;

	/* process the nonce */
	memset(state, 0, STATE_LEN);
	state[STATE_LEN-nlen-1] = PARAM;
	memcpy(state+STATE_LEN-nlen, nonce, nlen);
	LED80_enc(state, cxt->userkey);

	/* process the middle normal blocks of ad */
	unsigned long long i;
	for(i = 0; i < (unsigned long long)adlen/STATE_LEN; i++){
		xor_bytes(state, ad+STATE_LEN*i, STATE_LEN);
		LED80_enc(state, cxt->userkey);
	}
	/* process the last block partial block if any */
	unsigned long long lastblocklen = adlen % STATE_LEN;
	if(lastblocklen){
		xor_bytes(state, ad+i*STATE_LEN, lastblocklen);
		LED80_enc(state, cxt->userkey);
	}

	/* encode the adlen and process */
	unsigned long long t_adlen = adlen;
	for(i = 0; i < sizeof(unsigned long long); i++) {
		state[STATE_LEN-1-i] ^= t_adlen & 0xff;
		t_adlen >>= 8;
	}

	g(state);
	memcpy(cxt->ts, state, STATE_LEN);
	LED80_enc(state, cxt->userkey);

	g(cxt->ts);
	LED80_enc(cxt->ts, cxt->userkey);
	return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %r8, 0x38(%rdi)
movq $0x0, (%rdi)
movq %rdi, %rax
subq %r8, %rax
movb $-0x38, 0x7(%rax)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
subq %r8, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x10f0
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x10d0
cmpq $0x8, %r15
jae 0x1904
xorl %eax, %eax
jmp 0x193a
movq %r15, %rbp
shrq $0x3, %rbp
movq %r12, %r13
movq %rbx, %rdi
movq %r13, %rsi
movl $0x8, %edx
callq 0x10c0
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x10d0
addq $0x8, %r13
decq %rbp
jne 0x190e
movq %r15, %rax
andq $-0x8, %rax
movq %r15, %rdx
andq $0x7, %rdx
je 0x195d
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10c0
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x10d0
movl $0x8, %eax
xorb %r15b, -0x1(%rbx,%rax)
shrq $0x8, %r15
decq %rax
jne 0x1962
movb 0x1(%rbx), %al
movl 0x1(%rbx), %ecx
movzwl 0x5(%rbx), %edx
movw %dx, 0x4(%rbx)
movb 0x7(%rbx), %dl
xorb (%rbx), %al
movb %dl, 0x6(%rbx)
movl %ecx, (%rbx)
movb %al, 0x7(%rbx)
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x10d0
movb 0x9(%rbx), %al
movl 0x9(%rbx), %ecx
movzwl 0xd(%rbx), %edx
xorb 0x8(%rbx), %al
movb 0xf(%rbx), %sil
movb %sil, 0x6(%r14)
movw %dx, 0x4(%r14)
movl %ecx, (%r14)
movb %al, 0xf(%rbx)
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x10d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x60(%rbp), %rbx
movq $0x0, 0x18(%rbx)
xorl %eax, %eax
callq 0x6720
movq %rax, %r14
movq %rax, (%rbx)
leaq 0x3a99(%rip), %rcx      # 0xa004
movq %rax, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movl $0x32, %edx
callq 0x6a50
movq %rax, %r15
movq %rax, 0x8(%rbx)
leaq 0x3a7e(%rip), %rsi      # 0xa009
leaq -0x30(%rbp), %r12
leaq -0x2c(%rbp), %r13
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7b70
movq %rax, 0x10(%rbx)
leaq 0x3a69(%rip), %rsi      # 0xa015
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7b70
movq %rax, 0x20(%rbx)
leaq -0x109(%rip), %rsi      # 0x64bc
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6d40
movq (%rbx), %rdi
callq 0x6bd0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/parse.c
// Function: parse_contact
void parse_contact(char *name, cmesh theCMesh)
{ FILE *fp;
  static char theKeyword[80];
  point p;
  fprintf(stderr,"parsing contact...\n");
  if ( (fp=fopen(name,"r"))==(FILE *)NULL ) evaluate_level(RED,50);
  evaluate_level(GREEN,51);
  /* do something when a keyword is encountered: */
  while (!feof(fp))
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"CNODES")) fill_C_points(fp,theCMesh); 
  }
  /* calculate the cylinder normals: */
  p = (point)point_dll(theCMesh->merged_mesh->mesh_p,START,0);
  while (p!=(point)NULL)
  { if (p->type==CNODE) 
    { /* calculate_cyl_normal(p); */
      fprintf(stderr,"node %d, x: %f y %f z %f, has normals %f %f %f\n",p->label,
		p->x, p->y, p->z, p->n1, p->n2, p->n3);  
    }
    p=p->NEXT;
  }
  fprintf(stderr,"Contact parsed\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x12858(%rip), %rbp     # 0x14ff8
movq (%rbp), %rcx
leaq 0xc7fc(%rip), %rdi      # 0xefa7
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x11a0
leaq 0xd4e5(%rip), %rsi      # 0xfca2
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
testq %rax, %rax
jne 0x27d8
pushq $0x2
popq %rdi
pushq $0x32
popq %rsi
callq 0xb980
pushq $0x33
popq %rsi
xorl %edi, %edi
callq 0xb980
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
jne 0x2834
leaq 0x12eeb(%rip), %r15     # 0x156e0
leaq 0xc75f(%rip), %r12      # 0xef5b
pushq $0x7
popq %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x64fc
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1150
testl %eax, %eax
jne 0x2828
movq %r14, %rdi
movq %rbx, %rsi
callq 0x682e
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x2800
movq (%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
jne 0x286c
movq (%rbp), %rcx
leaq 0xc798(%rip), %rdi      # 0xefeb
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
movq %rax, %rbx
leaq 0xc745(%rip), %r14      # 0xefbb
cmpl $0xf, 0x14(%rbx)
je 0x2887
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2876
jmp 0x2848
movq (%rbp), %rdi
movl 0x10(%rbx), %edx
movsd 0x20(%rbx), %xmm0
movsd 0x28(%rbx), %xmm1
movsd 0x30(%rbx), %xmm2
movsd 0x68(%rbx), %xmm3
movsd 0x70(%rbx), %xmm4
movsd 0x78(%rbx), %xmm5
movq %r14, %rsi
movb $0x6, %al
callq 0x1100
jmp 0x287c
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/contactc.c
// Function: contact3
void contact3(cmesh theCMesh)
{ point       sourcenode;
  hypermatrix c;
  hypermatrix e;
  hypermatrix crow;
  hypermatrix erow;
  mesh theMesh;

  theMesh=theCMesh->merged_mesh;

  printstatusc(theMesh);
  init_linearc();


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

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

  tijdbalkjec(-1);

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

  close_linearc();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rbp
movq %rbp, %rdi
callq 0x28b8
callq 0x70ba
leaq 0x12860(%rip), %rax     # 0x15434
cmpl $0x0, (%rax)
je 0x2bec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7142
pushq $0x3
popq %r13
movl %r13d, %edi
movl %r13d, %esi
movl %r13d, %edx
callq 0xba88
movq %rax, %r14
movl %r13d, %edi
movl %r13d, %esi
movl %r13d, %edx
callq 0xba88
movq %rax, %r15
movl 0x12b68(%rip), %edx     # 0x15780
movl %r13d, %edi
movl %r13d, %esi
callq 0xba88
movq %rax, %r12
movl 0x12b54(%rip), %edx     # 0x15780
movl %r13d, %edi
movl %r13d, %esi
callq 0xba88
movq %rax, %r13
xorl %edi, %edi
callq 0x6f9c
movq (%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x2c9a
movq %rax, %rbp
movl 0x10(%rbp), %edi
callq 0x6f9c
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x7550
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x807c
movl 0x10(%rbp), %edi
movq %r12, %rsi
callq 0x797d
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x2c56
movq 0x12357(%rip), %rax     # 0x14ff8
movq (%rax), %rcx
leaq 0xb39f(%rip), %rdi      # 0xe04a
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
callq 0x11a0
movq %r14, %rdi
callq 0xbbdf
movq %r15, %rdi
callq 0xbbdf
movq %r12, %rdi
callq 0xbbdf
movq %r13, %rdi
callq 0xbbdf
jmp 0x2bd9
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/linearc.c
// Function: linear3
void linear3(mesh theMesh)
{ point       sourcenode;
  hypermatrix c;
  hypermatrix e;
  hypermatrix crow;
  hypermatrix erow;

  printstatus(theMesh);
  init_linear();

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

  make_rhs_vector(theMesh);

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

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

  close_linear();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2f82
callq 0x9f12
leaq 0x1219c(%rip), %rax     # 0x15434
cmpl $0x0, (%rax)
je 0x32b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9f91
pushq $0x3
popq %rbp
movl %ebp, %edi
movl %ebp, %esi
movl %ebp, %edx
callq 0xba88
movq %rax, %r14
movl %ebp, %edi
movl %ebp, %esi
movl %ebp, %edx
callq 0xba88
movq %rax, %r15
movl 0x125c3(%rip), %edx     # 0x15898
movl %ebp, %edi
movl %ebp, %esi
callq 0xba88
movq %rax, %r12
movl 0x125b1(%rip), %edx     # 0x15898
movl %ebp, %edi
movl %ebp, %esi
callq 0xba88
movq %rax, %r13
movq %rbx, %rdi
callq 0xa7a3
xorl %edi, %edi
callq 0x9df4
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x335a
movq %rax, %rbp
movl 0x10(%rbp), %edi
callq 0x9df4
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0xa466
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0xa5e3
movl 0x10(%rbp), %edi
movq %r13, %rsi
callq 0xa86a
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x3316
movq 0x11c97(%rip), %rax     # 0x14ff8
movq (%rax), %rcx
leaq 0xacdf(%rip), %rdi      # 0xe04a
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
callq 0x11a0
movq %r14, %rdi
callq 0xbbdf
movq %r15, %rdi
callq 0xbbdf
movq %r12, %rdi
callq 0xbbdf
movq %r13, %rdi
callq 0xbbdf
jmp 0x329d
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x3710
testl %edi, %edi
je 0x3709
cvtsi2ss %edi, %xmm0
cvtsi2ssl (%rsi), %xmm1
divss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x36b3
sqrtss %xmm0, %xmm0
jmp 0x36b8
callq 0x1120
mulss 0xa944(%rip), %xmm0     # 0xe004
cvttss2si %xmm0, %ebx
cmpl %ebx, 0x11d3a(%rip)     # 0x15404
jge 0x36fe
testl %ebx, %ebx
jle 0x36ea
movq 0x11921(%rip), %r14     # 0x14ff8
movl %ebx, %ebp
movq (%r14), %rsi
movl $0x3e, %edi
callq 0x10e0
decl %ebp
jne 0x36d9
movq 0x11907(%rip), %rax     # 0x14ff8
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10e0
movl %ebx, 0x11d00(%rip)     # 0x15404
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1eaa
jmp 0x3704
callq 0x1e8e
jmp 0x3704
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/solve.c
// Function: frontsolver
void frontsolver(matrix A, vector f, vector res)
{ int i,j,k;

  /* setup the elimination matrix: */
  for (i=1; i<=A->rows; i++)
  { for (k=1; k<i; k++)
	{ V(f,i)-=V(f,k)*M(A,i,k)/M(A,k,k);
	  for (j=1; j<=A->rows; j++)
	  { M(A,i,j)-=M(A,i,k)*M(A,k,j)/M(A,k,k);
	  }
	}
  }

  /* perform the backsubstitution: */
  for (i=A->rows; i>=1; i--)
  { V(res,i)=V(f,i)/M(A,i,i);
	for (k=A->rows; k>i; k--)
	{ V(res,i)-=M(A,i,k)*V(res,k)/M(A,i,i); 
	}
  }

}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
jle 0x382b
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1(%rax), %rcx
movl $0x1, %r8d
cmpq $0x2, %r8
jb 0x37b6
movq 0x8(%rsi), %r9
movq 0x8(%rdi), %r10
movq (%r10,%r8,8), %r11
movl $0x1, %ebx
movsd (%r9,%rbx,8), %xmm0
mulsd (%r11,%rbx,8), %xmm0
movq (%r10,%rbx,8), %r14
divsd (%r14,%rbx,8), %xmm0
movsd (%r9,%r8,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r8,8)
movl $0x1, %r15d
movsd (%r11,%rbx,8), %xmm0
mulsd (%r14,%r15,8), %xmm0
divsd (%r14,%rbx,8), %xmm0
movsd (%r11,%r15,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r11,%r15,8)
incq %r15
cmpq %r15, %rcx
jne 0x3784
incq %rbx
cmpq %r8, %rbx
jne 0x3758
incq %r8
cmpq %rcx, %r8
jne 0x3741
movq 0x8(%rsi), %rcx
movq 0x8(%rdi), %rsi
movq 0x8(%rdx), %rdx
movslq %eax, %rdi
movq %rax, %r8
movsd (%rcx,%r8,8), %xmm0
movq (%rsi,%r8,8), %r9
divsd (%r9,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
cmpq %rax, %r8
jge 0x3819
movq %rdi, %r10
movl %r10d, %r11d
shlq $0x3, %r11
movsd (%r9,%r11), %xmm1
mulsd (%rdx,%r11), %xmm1
divsd (%r9,%r8,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%r8,8)
decq %r10
cmpq %r10, %r8
jl 0x37ee
leaq -0x1(%r8), %r9
cmpq $0x1, %r8
movq %r9, %r8
jg 0x37d0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xac7e(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa955(%rip), %rdi      # 0xe7b7
callq 0x1060
leaq 0xacd6(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa968(%rip), %rdi      # 0xe7e2
callq 0x1060
leaq 0xac8f(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa987(%rip), %rdi      # 0xe819
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb570
testq %rax, %rax
je 0x3ed2
movq %rax, %rbx
leaq 0xa5e6(%rip), %r14      # 0xe498
movl 0x14(%rbx), %esi
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
movl 0x20(%rbx), %r8d
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3eb2
leaq 0xa94e(%rip), %rdi      # 0xe827
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xabe1(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa936(%rip), %rdi      # 0xe835
callq 0x1060
leaq 0xac39(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa947(%rip), %rdi      # 0xe85e
callq 0x1060
leaq 0xabf2(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa9d8(%rip), %rdi      # 0xe907
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x3f74
movq %rax, %rbx
leaq 0xa55b(%rip), %r14      # 0xe4aa
movl 0x10(%rbx), %esi
movsd 0x50(%rbx), %xmm0
movsd 0x58(%rbx), %xmm1
movsd 0x60(%rbx), %xmm2
movq %r14, %rdi
movb $0x3, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3f4f
leaq 0xa91d(%rip), %rdi      # 0xe898
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xab3f(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa90f(%rip), %rdi      # 0xe8b0
callq 0x1060
leaq 0xab97(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa926(%rip), %rdi      # 0xe8df
callq 0x1060
leaq 0xab50(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa930(%rip), %rdi      # 0xe901
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x4025
movq %rax, %rbx
leaq 0xa4b9(%rip), %r14      # 0xe4aa
movsd 0x50(%rbx), %xmm0
addsd 0x20(%rbx), %xmm0
movsd 0x58(%rbx), %xmm1
addsd 0x28(%rbx), %xmm1
movl 0x10(%rbx), %esi
movsd 0x60(%rbx), %xmm2
addsd 0x30(%rbx), %xmm2
movq %r14, %rdi
movb $0x3, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3ff1
leaq 0xa8ee(%rip), %rdi      # 0xe91a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xaa8e(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa8e6(%rip), %rdi      # 0xe938
callq 0x1060
leaq 0xaae6(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xaae4(%rip), %rdi      # 0xeb4e
callq 0x1060
leaq 0xaa9f(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xab02(%rip), %rdi      # 0xeb84
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x40c7
movq %rax, %rbx
leaq 0xa408(%rip), %r14      # 0xe4aa
movl 0x10(%rbx), %esi
movsd 0x38(%rbx), %xmm0
movsd 0x40(%rbx), %xmm1
movsd 0x48(%rbx), %xmm2
movq %r14, %rdi
movb $0x3, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x40a2
leaq 0xa88f(%rip), %rdi      # 0xe95d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa1bd(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa1f4(%rip), %rdi      # 0xeb17
callq 0x1060
leaq 0xa215(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa213(%rip), %rdi      # 0xeb4e
callq 0x1060
leaq 0xa1ce(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa229(%rip), %rdi      # 0xeb7c
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc2f
testq %rax, %rax
je 0x49a3
movq %rax, %rbx
leaq 0x9c02(%rip), %r14      # 0xe575
cmpl $0xf, 0x14(%rbx)
jne 0x499a
movl 0x10(%rbx), %esi
movsd 0x38(%rbx), %xmm0
movsd 0x40(%rbx), %xmm1
movsd 0x48(%rbx), %xmm2
movsd 0x28(%rbx), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x4973
leaq 0xa1e9(%rip), %rdi      # 0xeb93
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movl 0x18(%rbx), %edx
movl $0x2, %esi
callq 0xcc2f
xorl %r15d, %r15d
cmpl $0xf, 0x14(%rax)
sete %r15b
movq (%r14), %rdi
movl 0x1c(%rbx), %edx
movl $0x2, %esi
callq 0xcc2f
leal 0x1(%r15), %ebp
cmpl $0xf, 0x14(%rax)
cmovnel %r15d, %ebp
movq (%r14), %rdi
movl 0x20(%rbx), %edx
movl $0x2, %esi
callq 0xcc2f
xorl %ecx, %ecx
cmpl $0xf, 0x14(%rax)
sete %cl
addl %ebp, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0xb570
testq %rax, %rax
je 0x4a79
movq %rax, %r15
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49b6
cmpl $0x2, %eax
jne 0x4a70
movl 0x10(%r14), %eax
cmpl %eax, 0x18(%r15)
je 0x4a6e
cmpl %eax, 0x1c(%r15)
je 0x4a6e
cmpl %eax, 0x20(%r15)
jne 0x4a70
incl %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x4a48
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq (%r8), %rdi
movl 0x18(%r15), %edx
movl $0x2, %esi
callq 0xcc2f
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq (%r14), %rdi
movl 0x1c(%r15), %edx
movl $0x2, %esi
callq 0xcc2f
movq (%r14), %rdi
movl 0x20(%r15), %edx
movsd 0x8(%rsp), %xmm0
addsd 0x38(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x40(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x2, %esi
callq 0xcc2f
movsd 0x8(%rsp), %xmm1
addsd 0x38(%rax), %xmm1
movsd 0x9914(%rip), %xmm0     # 0xe450
mulsd %xmm0, %xmm1
mulsd 0xb8(%r15), %xmm1
mulsd 0x30(%r14), %xmm1
movapd %xmm1, %xmm3
movsd 0x10(%rsp), %xmm2
addsd 0x40(%rax), %xmm2
movsd 0x18(%rsp), %xmm1
addsd 0x48(%rax), %xmm1
movsd %xmm3, (%r13)
mulsd %xmm0, %xmm2
mulsd 0xb8(%r15), %xmm2
mulsd 0x30(%r14), %xmm2
movsd %xmm2, (%r12)
mulsd %xmm0, %xmm1
mulsd 0xb8(%r15), %xmm1
mulsd 0x30(%r14), %xmm1
movsd %xmm1, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markpeerdeman[P]mbemm/src/emath/post.c
// Function: elforce2
void elforce2(element e, double *fx, double *fy, double *fz, mesh theMesh)
{ point p;
  double t1x, t1y, t1z, t2x, t2y, t2z, t3x, t3y, t3z;

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

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

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

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

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

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

  printf("    -1\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x9159(%rip), %rdi      # 0xeda0
callq 0x1060
leaq 0x905d(%rip), %rdi      # 0xecb0
callq 0x1060
leaq 0x9023(%rip), %r14      # 0xec82
movq %r14, %rdi
callq 0x1060
leaq 0x902d(%rip), %rdi      # 0xec9b
callq 0x1060
movq %r14, %rdi
callq 0x1060
leaq 0x9051(%rip), %rdi      # 0xecd3
callq 0x1060
leaq 0x905c(%rip), %rdi      # 0xecea
callq 0x1060
leaq 0x9061(%rip), %rdi      # 0xecfb
callq 0x1060
leaq 0x9060(%rip), %rdi      # 0xed06
callq 0x1060
leaq 0x9082(%rip), %rdi      # 0xed34
callq 0x1060
leaq 0x907b(%rip), %rdi      # 0xed39
callq 0x1060
leaq 0x8901(%rip), %rdi      # 0xe5cb
xorl %eax, %eax
callq 0x1090
leaq 0x909e(%rip), %rdi      # 0xed76
callq 0x1060
leaq 0x90a7(%rip), %rdi      # 0xed8b
callq 0x1060
leaq 0x8918(%rip), %r14      # 0xe608
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
leaq 0x893b(%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 0x5d6c
movq %rax, %rbx
leaq 0x8935(%rip), %r14      # 0xe66b
leaq 0x896b(%rip), %r15      # 0xe6a8
movl 0x10(%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
movsd 0x50(%rbx), %xmm0
movsd 0x58(%rbx), %xmm1
movsd 0x60(%rbx), %xmm2
movq %r15, %rdi
movb $0x3, %al
callq 0x1090
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x5d3d
leaq 0x902d(%rip), %rdi      # 0xeda0
popq %rbx
popq %r14
popq %r15
jmp 0x1060