LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/baskerville[P]bspwm/src/helpers.c
// Function: tokenize_with_escape
char *tokenize_with_escape(struct tokenize_state *state, const char *s, char sep)
{
	if (s != NULL) {
		// first call
		state->in_escape = false;
		state->pos = s;
		state->len = strlen(s) + 1;
	}

	char *outp = calloc(state->len, 1);
	char *ret = outp;
	if (!outp) return NULL;

	char cur;
	while (*state->pos) {
		--state->len;
		cur = *state->pos++;

		if (state->in_escape) {
			*outp++ = cur;
			state->in_escape = false;
			continue;
		}

		if (cur == '\\') {
			state->in_escape = !state->in_escape;
		} else if (cur == sep) {
			return ret;
		} else {
			*outp++ = cur;
		}
	}

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1aa2
movb $0x0, (%r14)
movq %rsi, 0x8(%r14)
movq %rsi, %rdi
callq 0x10d0
incq %rax
movq %rax, 0x10(%r14)
movq 0x10(%r14), %rdi
movl $0x1, %esi
callq 0x11a0
testq %rax, %rax
je 0x1aff
movq 0x8(%r14), %rdx
cmpb $0x0, (%rdx)
je 0x1b01
movq %rax, %rcx
decq 0x10(%r14)
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%r14)
movb (%rdx), %dl
cmpb $0x1, (%r14)
jne 0x1ae0
movb %dl, (%rcx)
incq %rcx
movb $0x0, (%r14)
jmp 0x1af4
cmpb $0x5c, %dl
jne 0x1aeb
movb $0x1, (%r14)
jmp 0x1af4
cmpb %bl, %dl
je 0x1b01
movb %dl, (%rcx)
incq %rcx
movq 0x8(%r14), %rdx
cmpb $0x0, (%rdx)
jne 0x1ac1
jmp 0x1b01
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1810
testb %al, %al
je 0x13c9
leaq 0x2df8(%rip), %rdi      # 0x41bc
callq 0x1817
xorl %edi, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O1/DrYerzinia[P]C_DigiMode/src/sound_device/UARTRecord.c
// Function: main
int main(int argc, char **argv){

	signal(SIGINT, int_handler);

	struct arguments arguments;

	arguments.device_name = NULL;
	arguments.baud_rate = 230400;

	argp_parse(&argp, argc, argv, 0, 0, &arguments);

	if(arguments.device_name == NULL){
		fprintf(stderr, "Please specify a serial port to read from\n");
		return -1;
	}

	int status = UART_open(&uart, arguments.device_name, arguments.baud_rate);

	if(status != 0){
		fprintf(stderr, "Could not open serial port, terminating\n");
		return -1;
	}

	char buffer[BUFFER_SIZE];

	while(true){

		int bytes_read = UART_read(&uart, buffer, BUFFER_SIZE);
		if(bytes_read <= 0){
			fprintf(stderr, "Error reading! %d\n", bytes_read);
			break;
		}

		int bytes_written = fwrite(buffer, sizeof(char), bytes_read, stdout);
		if(bytes_written != bytes_read){
			fprintf(stderr, "Error writing!\n");
			break;
		}

		fflush(stdout);

	}

	fprintf(stderr, "Loop broken, closing...\n");

	UART_close(&uart);

	return 0;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq -0x5c(%rip), %rsi       # 0x138c
movl $0x2, %edi
callq 0x1090
movq %rsp, %r14
movq $0x0, (%r14)
movl $0x38400, 0x8(%r14)     # imm = 0x38400
leaq 0x2ca5(%rip), %rdi      # 0x40b0
movl %ebp, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1080
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x142f
callq 0x1194
jmp 0x14cd
movl 0x8(%rsp), %edx
leaq 0x2d82(%rip), %rdi      # 0x41bc
callq 0x153c
testl %eax, %eax
jne 0x14c8
leaq 0x2d6e(%rip), %rdi      # 0x41bc
leaq 0x10(%rsp), %rsi
movl $0x19, %edx
callq 0x1888
movl %eax, %ebx
testl %eax, %eax
jle 0x14ac
movq 0x2b6e(%rip), %r12      # 0x3fd8
leaq 0x10(%rsp), %r14
leaq 0x2d46(%rip), %r15      # 0x41bc
movl %ebx, %edx
movq (%r12), %rcx
movl $0x1, %esi
movq %r14, %rdi
callq 0x1130
cmpl %eax, %ebx
jne 0x14d4
movq (%r12), %rdi
callq 0x10b0
movq %r15, %rdi
movq %r14, %rsi
movl $0x19, %edx
callq 0x1888
movl %eax, %ebx
testl %eax, %eax
jg 0x1476
movq 0x2b45(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbaf(%rip), %rsi       # 0x206c
movl %ebx, %edx
xorl %eax, %eax
callq 0x10a0
jmp 0x14d9
callq 0x1150
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1507
callq 0x1172
movq 0x2b18(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xba5(%rip), %rdi       # 0x208f
movl $0x18, %esi
movl $0x1, %edx
callq 0x1130
leaq 0x2cbc(%rip), %rdi      # 0x41bc
callq 0x1817
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1875
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8f3(%rip), %rdi       # 0x216f
callq 0x1100
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1869
// File: /workspace/github_c_makefile_star2_O1/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 0x18ab
popq %rbx
retq
leaq 0x8d4(%rip), %rdi       # 0x2186
callq 0x1100
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x18a9
// File: /workspace/github_c_makefile_star2_O1/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 0xb1b9
movq 0x8(%rsi), %rdi
leaq 0xe56(%rip), %rsi       # 0xc004
callq 0xb050
testl %eax, %eax
setne %bpl
movq 0x4e18(%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 0xb818
testl %eax, %eax
js 0xb25b
testb %bpl, %bpl
je 0xb21b
movl %eax, %edx
movq 0x4dc7(%rip), %rax      # 0xffd0
movq (%rax), %rcx
movq %rsp, %rdi
movl $0x1, %esi
callq 0xb070
jmp 0xb247
testl %eax, %eax
je 0xb247
movl %eax, %r15d
xorl %ebx, %ebx
leaq 0xdf1(%rip), %r14       # 0xc01c
xorl %r12d, %r12d
movzbl (%rsp,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0xb040
incq %r12
cmpq %r12, %r15
jne 0xb22e
jmp 0xb249
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xa0000, %rsp          # imm = 0xA0000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4d96(%rip), %rcx      # 0xfff8
movq (%rcx), %rdi
leaq 0xd9b(%rip), %rsi       # 0xc007
movl %eax, %edx
xorl %eax, %eax
callq 0xb060
movl $0x1, %ebx
jmp 0xb249
// File: /workspace/github_c_makefile_star2_O1/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 0xb387
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 0xb387
movl %edx, %ecx
movl $0xaaaaaaab, %r8d       # imm = 0xAAAAAAAB
imulq %rcx, %r8
shrq $0x21, %r8
leal (,%r8,4), %ecx
subl %ecx, %esi
jle 0xb387
leal (%r8,%r8,2), %eax
subl %eax, %edx
cmpl $0x4, %esi
movl $0x4, %r8d
cmovll %esi, %r8d
movl %ecx, %ecx
cmpl $0x2, %r8d
movl $0x1, %eax
cmovgel %r8d, %eax
addq %rcx, %rdi
shlq $0x3, %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
movzbl (%rdi), %r9d
shlq %cl, %r9
orq %r9, %r8
incq %rdi
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0xb30a
movabsq $-0x5ec7a2cb6a1d9959, %rcx # imm = 0xA1385D3495E266A7
cmpl $0x1, %edx
je 0xb35f
cmpl $0x2, %edx
jne 0xb36c
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 0xb36e
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_O1/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 0xb3e0
callq 0xb080
incq %r15
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
jne 0xb3dd
movq %r15, (%rbx)
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0xb3c1
decq %r15
movq (%rbx), %r14
movb (%r14), %bpl
testb %bpl, %bpl
je 0xb444
callq 0xb080
incq %r14
xorl %ecx, %ecx
movq (%rax), %rdx
movsbq %bpl, %rsi
testb $0x4, 0x1(%rdx,%rsi,2)
je 0xb440
cmpq $0x17, %rcx
ja 0xb440
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 0xb3f5
movl %edx, %ecx
movl %ecx, %eax
jmp 0xb446
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
movq (%rbx), %r14
movb (%r14), %bpl
testb %bpl, %bpl
je 0xb479
callq 0xb080
incq %r14
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
je 0xb479
movq %r14, (%rbx)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0xb45d
movq (%rbx), %r14
movb (%r14), %bpl
testb %bpl, %bpl
je 0xb4a8
callq 0xb080
incq %r14
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
jne 0xb4a8
movq %r14, (%rbx)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0xb48c
xorl %ebp, %ebp
cmpb $0x0, (%rsp)
je 0xb4e5
movl $0x1, %r12d
leaq 0x4bb3(%rip), %r13      # 0x10070
movq %rsp, %r14
movq (%r13,%r12,8), %rsi
movq %r14, %rdi
callq 0xb050
testl %eax, %eax
je 0xb4e2
incq %r12
cmpq $0x662, %r12            # imm = 0x662
jne 0xb4c0
movq %r15, (%rbx)
jmp 0xb4e5
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_O1/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 0xb39d
testl %eax, %eax
je 0xb869
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
movl %eax, %edi
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0xb4f6
movq %r12, %rdi
callq 0xb39d
testl %eax, %eax
jne 0xb84e
movq 0x10(%rsp), %rcx
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
cmpb $0x0, (%rcx)
jne 0xb891
leaq 0xc(%rsp), %rcx
xorl %edi, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb4f6
testl %eax, %eax
js 0xb891
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
btl %edx, %esi
movzbl %dil, %edi
movl %edi, %r8d
cmovael %ecx, %r8d
xorb %r8b, %al
leal (%rdi,%rdi), %r8d
movzbl %r8b, %r9d
xorb $0x3, %r8b
testb $0x8, %dil
movzbl %r8b, %edi
cmovel %r9d, %edi
incl %edx
cmpl $0x4, %edx
jne 0x1362
andb $0xf, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testb $0x1, %dl
jne 0x13c0
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
xorb %dl, (%rdi,%rcx)
incq %rcx
cmpq $0x4, %rcx
jne 0x139e
incq %rax
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rax
jne 0x139c
jmp 0x13fc
movq 0x2c29(%rip), %rcx      # 0x3ff0
xorl %edx, %edx
xorl %r8d, %r8d
cmpl $0x41, (%rcx)
setge %r8b
shll $0x4, %r8d
addq %rsi, %r8
movb (%rdx,%r8), %r8b
xorb %r8b, (%rdi,%rdx)
incq %rdx
cmpq $0x4, %rdx
jne 0x13c9
incq %rax
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rax
jne 0x13c7
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb 0x4(%rdi), %al
movb 0x8(%rdi), %cl
xorb $0x1, %al
movb %al, 0x4(%rdi)
xorb $0x2, %cl
movb %cl, 0x8(%rdi)
movb 0xc(%rdi), %dl
xorb $0x3, %dl
movb %dl, 0xc(%rdi)
movq 0x2bd2(%rip), %r8       # 0x3ff0
movb (%r8), %r9b
shrb $0x4, %r9b
xorb %r9b, (%rdi)
movb (%r8), %r8b
movl %r8d, %r9d
shrb $0x4, %r9b
xorb %al, %r9b
movb %r9b, 0x4(%rdi)
andb $0xf, %r8b
xorb %r8b, %cl
movb %cl, 0x8(%rdi)
xorb %dl, %r8b
movb %r8b, 0xc(%rdi)
movslq %esi, %rax
leaq 0xbec(%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_O1/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:
addq $0x4, %rdi
movl $0x1, %eax
xorl %ecx, %ecx
movq %rdi, %rdx
movl (%rdi,%rcx,4), %esi
movl %esi, -0x4(%rsp)
xorl %esi, %esi
leal (%rax,%rsi), %r8d
andl $0x3, %r8d
movb -0x4(%rsp,%r8), %r8b
movb %r8b, (%rdx,%rsi)
incq %rsi
cmpq $0x4, %rsi
jne 0x14b3
incq %rax
incq %rcx
addq $0x4, %rdx
cmpq $0x3, %rcx
jne 0x14aa
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2adf(%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 0x151c
andb $0xf, %bl
xorb %bl, %r11b
incq %r9
cmpq $0x4, %r9
jne 0x1507
movb %r11b, -0x4(%rsp,%r8)
incq %r8
cmpq $0x4, %r8
jne 0x14f9
xorl %r8d, %r8d
movb -0x4(%rsp,%r8), %r9b
movb %r9b, (%rdx,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x156f
incq %rsi
incq %rdx
cmpq $0x4, %rsi
jne 0x14f6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18cd
xorl %r13d, %r13d
jmp 0x18fd
movq %r15, %rbp
shrq $0x3, %rbp
xorl %r13d, %r13d
leaq (%r12,%r13), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x10c0
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x10d0
addq $0x8, %r13
decq %rbp
jne 0x18d7
movq %r15, %rdx
andq $0x7, %rdx
je 0x1920
addq %r13, %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 0x1925
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_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
movl %r15d, 0xc(%rsp)
movl %r15d, (%rsp)
movl $0xca, %edi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x2150
incq (%rbx)
jmp 0x2be0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x61, %edi
je 0x64e6
cmpl $0x64, %edi
je 0x64df
cmpl $0x70, %edi
jne 0x64ee
movl $0x1, %edi
callq 0x6360
movl $0x14, %eax
jmp 0x64eb
movl $0xffffffec, %eax       # imm = 0xFFFFFFEC
addl %eax, 0x18(%rbx)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x7040
xorl %r14d, %r14d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x20(%rbx), %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x6f00
addl $0x32, %r14d
cmpl $0x1f4, %r14d           # imm = 0x1F4
jne 0x64fd
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x6f00
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x38, %rsp
leaq -0x50(%rbp), %rbx
movq $0x0, 0x18(%rbx)
xorl %eax, %eax
callq 0x6710
movq %rax, (%rbx)
leaq 0x3aa0(%rip), %rcx      # 0xa004
movq %rax, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movl $0x32, %edx
callq 0x6a40
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x3a85(%rip), %rsi      # 0xa009
leaq -0x20(%rbp), %r14
leaq -0x1c(%rbp), %r15
movq %r14, %rdx
movq %r15, %rcx
callq 0x7b60
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
leaq 0x3a70(%rip), %rsi      # 0xa015
movq %r14, %rdx
movq %r15, %rcx
callq 0x7b60
movq %rax, 0x20(%rbx)
movq 0x8(%rbx), %rdi
leaq -0x103(%rip), %rsi      # 0x64bc
movq %rbx, %rdx
callq 0x6d30
movq (%rbx), %rdi
callq 0x6bc0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x128b9(%rip), %rbp     # 0x14ff8
movq (%rbp), %rcx
leaq 0xc85d(%rip), %rdi      # 0xefa7
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x11a0
leaq 0xd546(%rip), %rsi      # 0xfca2
movq %r14, %rdi
callq 0x1160
movq %rax, %r14
testq %rax, %rax
jne 0x2777
pushq $0x2
popq %rdi
pushq $0x32
popq %rsi
callq 0xbc50
pushq $0x33
popq %rsi
xorl %edi, %edi
callq 0xbc50
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
jne 0x27d3
leaq 0x12f4c(%rip), %r15     # 0x156e0
leaq 0xc7c0(%rip), %r12      # 0xef5b
pushq $0x7
popq %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x658c
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1150
testl %eax, %eax
jne 0x27c7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68cc
movq %r14, %rdi
callq 0x1110
testl %eax, %eax
je 0x279f
movq (%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
jne 0x280b
movq (%rbp), %rcx
leaq 0xc7f9(%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 0xc7a6(%rip), %r14      # 0xefbb
cmpl $0xf, 0x14(%rbx)
je 0x2826
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2815
jmp 0x27e7
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 0x281b
// File: /workspace/github_c_makefile_star2_O1/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 0x2857
callq 0x717e
leaq 0x128a3(%rip), %rax     # 0x15434
cmpl $0x0, (%rax)
je 0x2ba9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7206
pushq $0x3
popq %r13
movl %r13d, %edi
movl %r13d, %esi
movl %r13d, %edx
callq 0xbd58
movq %rax, %r14
movl %r13d, %edi
movl %r13d, %esi
movl %r13d, %edx
callq 0xbd58
movq %rax, %r15
movl 0x12bab(%rip), %edx     # 0x15780
movl %r13d, %edi
movl %r13d, %esi
callq 0xbd58
movq %rax, %r12
movl 0x12b97(%rip), %edx     # 0x15780
movl %r13d, %edi
movl %r13d, %esi
callq 0xbd58
movq %rax, %r13
xorl %edi, %edi
callq 0x7060
movq (%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x2c57
movq %rax, %rbp
movl 0x10(%rbp), %edi
callq 0x7060
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x7620
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x81bc
movl 0x10(%rbp), %edi
movq %r12, %rsi
callq 0x7a9e
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x2c13
movq 0x1239a(%rip), %rax     # 0x14ff8
movq (%rax), %rcx
leaq 0xb3e2(%rip), %rdi      # 0xe04a
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
callq 0x11a0
movq %r14, %rdi
callq 0xbeaf
movq %r15, %rdi
callq 0xbeaf
movq %r12, %rdi
callq 0xbeaf
movq %r13, %rdi
callq 0xbeaf
jmp 0x2b96
// File: /workspace/github_c_makefile_star2_O1/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 0x2f3f
callq 0xa042
leaq 0x121c1(%rip), %rax     # 0x15434
cmpl $0x0, (%rax)
je 0x328b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa0c1
pushq $0x3
popq %rbp
movl %ebp, %edi
movl %ebp, %esi
movl %ebp, %edx
callq 0xbd58
movq %rax, %r14
movl %ebp, %edi
movl %ebp, %esi
movl %ebp, %edx
callq 0xbd58
movq %rax, %r15
movl 0x125e8(%rip), %edx     # 0x15898
movl %ebp, %edi
movl %ebp, %esi
callq 0xbd58
movq %rax, %r12
movl 0x125d6(%rip), %edx     # 0x15898
movl %ebp, %edi
movl %ebp, %esi
callq 0xbd58
movq %rax, %r13
movq %rbx, %rdi
callq 0xa8db
xorl %edi, %edi
callq 0x9f24
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x3335
movq %rax, %rbp
movl 0x10(%rbp), %edi
callq 0x9f24
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0xa5a2
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0xa71b
movl 0x10(%rbp), %edi
movq %r13, %rsi
callq 0xa9a2
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x32f1
movq 0x11cbc(%rip), %rax     # 0x14ff8
movq (%rax), %rcx
leaq 0xad04(%rip), %rdi      # 0xe04a
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
callq 0x11a0
movq %r14, %rdi
callq 0xbeaf
movq %r15, %rdi
callq 0xbeaf
movq %r12, %rdi
callq 0xbeaf
movq %r13, %rdi
callq 0xbeaf
jmp 0x3278
// File: /workspace/github_c_makefile_star2_O1/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 0x36f0
testl %edi, %edi
je 0x36e9
cvtsi2ss %edi, %xmm0
cvtsi2ssl (%rsi), %xmm1
divss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x3693
sqrtss %xmm0, %xmm0
jmp 0x3698
callq 0x1120
mulss 0xa964(%rip), %xmm0     # 0xe004
cvttss2si %xmm0, %ebx
cmpl %ebx, 0x11d5a(%rip)     # 0x15404
jge 0x36de
testl %ebx, %ebx
jle 0x36ca
movq 0x11941(%rip), %r14     # 0x14ff8
movl %ebx, %ebp
movq (%r14), %rsi
movl $0x3e, %edi
callq 0x10e0
decl %ebp
jne 0x36b9
movq 0x11927(%rip), %rax     # 0x14ff8
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10e0
movl %ebx, 0x11d20(%rip)     # 0x15404
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1e37
jmp 0x36e4
callq 0x1e1b
jmp 0x36e4
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %eax
testl %eax, %eax
jle 0x37a4
leaq 0x1(%rax), %rcx
movl %ecx, %r8d
movl $0x1, %r9d
cmpq $0x2, %r9
jb 0x379c
movq 0x8(%rsi), %r10
movq 0x8(%rdi), %r11
movq (%r11,%r9,8), %rbx
movl $0x1, %r14d
movsd (%r10,%r14,8), %xmm0
mulsd (%rbx,%r14,8), %xmm0
movq (%r11,%r14,8), %r15
divsd (%r15,%r14,8), %xmm0
movsd (%r10,%r9,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r10,%r9,8)
movl $0x1, %r12d
movsd (%rbx,%r14,8), %xmm0
mulsd (%r15,%r12,8), %xmm0
divsd (%r15,%r14,8), %xmm0
movsd (%rbx,%r12,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r8
jne 0x376a
incq %r14
cmpq %r9, %r14
jne 0x373e
incq %r9
cmpq %rcx, %r9
jne 0x3726
testl %eax, %eax
jle 0x3816
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 0x3809
movq %rdi, %r10
movl %r10d, %r11d
shlq $0x3, %r11
movsd (%r9,%r11), %xmm0
mulsd (%rdx,%r11), %xmm0
divsd (%r9,%r8,8), %xmm0
movsd (%rdx,%r8,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%r8,8)
decq %r10
cmpq %r10, %r8
jl 0x37d8
leaq -0x1(%r8), %r9
cmpq $0x1, %r8
movq %r9, %r8
jg 0x37ba
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xac8e(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa965(%rip), %rdi      # 0xe7b7
callq 0x1060
leaq 0xace6(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa978(%rip), %rdi      # 0xe7e2
callq 0x1060
leaq 0xac9f(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa997(%rip), %rdi      # 0xe819
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb834
testq %rax, %rax
je 0x3ec2
movq %rax, %rbx
leaq 0xa5f6(%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 0x3ea2
leaq 0xa95e(%rip), %rdi      # 0xe827
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0xabf1(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa946(%rip), %rdi      # 0xe835
callq 0x1060
leaq 0xac49(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa957(%rip), %rdi      # 0xe85e
callq 0x1060
leaq 0xac02(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa9e8(%rip), %rdi      # 0xe907
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x3f64
movq %rax, %rbx
leaq 0xa56b(%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 0x3f3f
leaq 0xa92d(%rip), %rdi      # 0xe898
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0xab4f(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa91f(%rip), %rdi      # 0xe8b0
callq 0x1060
leaq 0xaba7(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa936(%rip), %rdi      # 0xe8df
callq 0x1060
leaq 0xab60(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa940(%rip), %rdi      # 0xe901
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x4015
movq %rax, %rbx
leaq 0xa4c9(%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 0x3fe1
leaq 0xa8fe(%rip), %rdi      # 0xe91a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0xaa9e(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa8f6(%rip), %rdi      # 0xe938
callq 0x1060
leaq 0xaaf6(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xaaf4(%rip), %rdi      # 0xeb4e
callq 0x1060
leaq 0xaaaf(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xab12(%rip), %rdi      # 0xeb84
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x40b7
movq %rax, %rbx
leaq 0xa418(%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 0x4092
leaq 0xa89f(%rip), %rdi      # 0xe95d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0xa1a3(%rip), %rdi      # 0xead4
callq 0x1060
leaq 0xa1da(%rip), %rdi      # 0xeb17
callq 0x1060
leaq 0xa1fb(%rip), %rdi      # 0xeb44
callq 0x1060
leaq 0xa1f9(%rip), %rdi      # 0xeb4e
callq 0x1060
leaq 0xa1b4(%rip), %rdi      # 0xeb15
callq 0x1060
leaq 0xa20f(%rip), %rdi      # 0xeb7c
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcf07
testq %rax, %rax
je 0x49bd
movq %rax, %rbx
leaq 0x9be8(%rip), %r14      # 0xe575
cmpl $0xf, 0x14(%rbx)
jne 0x49b4
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 0x498d
leaq 0xa1cf(%rip), %rdi      # 0xeb93
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0xcf07
xorl %r15d, %r15d
cmpl $0xf, 0x14(%rax)
sete %r15b
movq (%r14), %rdi
movl 0x1c(%rbx), %edx
movl $0x2, %esi
callq 0xcf07
leal 0x1(%r15), %ebp
cmpl $0xf, 0x14(%rax)
cmovnel %r15d, %ebp
movq (%r14), %rdi
movl 0x20(%rbx), %edx
movl $0x2, %esi
callq 0xcf07
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_O1/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 0xb834
testq %rax, %rax
je 0x4a93
movq %rax, %r15
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49d0
cmpl $0x2, %eax
jne 0x4a8a
movl 0x10(%r14), %eax
cmpl %eax, 0x18(%r15)
je 0x4a88
cmpl %eax, 0x1c(%r15)
je 0x4a88
cmpl %eax, 0x20(%r15)
jne 0x4a8a
incl %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x4a62
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf07
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq (%r14), %rdi
movl 0x1c(%r15), %edx
movl $0x2, %esi
callq 0xcf07
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 0xcf07
movsd 0x8(%rsp), %xmm1
addsd 0x38(%rax), %xmm1
movsd 0x98fa(%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