LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %ecx, %ecx
testl %edx, %edx
js 0xb321
movl %edx, %r8d
leal (%rsi,%rsi,2), %eax
addl $0x3, %eax
pushq $0x4
popq %r9
cltd
idivl %r9d
cmpl %r8d, %eax
jle 0xb321
pushq $0x3
popq %rcx
movl %r8d, %eax
xorl %edx, %edx
divl %ecx
xorl %ecx, %ecx
shll $0x2, %eax
subl %eax, %esi
jle 0xb321
cmpl $0x4, %esi
cmovbl %esi, %r9d
movl %eax, %eax
addq %rax, %rdi
shll $0x3, %r9d
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rcx, %r9
je 0xb2e4
movzbl (%rdi), %r8d
shlq %cl, %r8
orq %r8, %rax
incq %rdi
addq $0x8, %rcx
jmp 0xb2cc
cmpl $0x1, %edx
je 0xb303
cmpl $0x2, %edx
jne 0xb311
xorl %edx, %edx
cmpl $0x3, %esi
movl $0x65a, %ecx            # imm = 0x65A
cmovneq %rdx, %rcx
movl $0x2857a4, %esi         # imm = 0x2857A4
jmp 0xb30a
xorl %ecx, %ecx
movl $0x65a, %esi            # imm = 0x65A
xorl %edx, %edx
divq %rsi
jmp 0xb313
xorl %ecx, %ecx
movl $0x65a, %esi            # imm = 0x65A
xorl %edx, %edx
divq %rsi
addl %edx, %ecx
incl %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r14
incq %r14
movsbq -0x1(%r14), %r12
testq %r12, %r12
je 0xb36f
callq 0xb080
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r12,2)
jne 0xb36f
movq %r14, (%rbx)
jmp 0xb34d
leaq -0x1(%r14), %r15
xorl %r13d, %r13d
testb %r12b, %r12b
je 0xb3bf
callq 0xb080
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0xb3bf
cmpq $0x17, %r13
ja 0xb3bf
leaq (%r14,%r13), %rax
movq %rax, (%rbx)
movzbl -0x1(%r14,%r13), %eax
leal -0x41(%rax), %ecx
movl %eax, %edx
orb $0x20, %dl
cmpb $0x1a, %cl
movzbl %dl, %ecx
cmovael %eax, %ecx
movb %cl, (%rsp,%r13)
movb (%r14,%r13), %r12b
incq %r13
jmp 0xb376
movb $0x0, (%rsp,%r13)
addq %r13, %r14
testb %r12b, %r12b
je 0xb406
callq 0xb080
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0xb406
movq %r14, (%rbx)
movb (%r14), %r12b
incq %r14
jmp 0xb3c7
callq 0xb080
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0xb40b
movq %r14, (%rbx)
movb (%r14), %r12b
incq %r14
testb %r12b, %r12b
jne 0xb3ea
xorl %ebp, %ebp
cmpb $0x0, (%rsp)
je 0xb448
pushq $0x1
popq %r12
leaq 0x4c52(%rip), %r13      # 0x10070
movq %rsp, %r14
cmpq $0x662, %r12            # imm = 0x662
je 0xb440
movq (%r13,%r12,8), %rsi
movq %r14, %rdi
callq 0xb050
testl %eax, %eax
je 0xb445
incq %r12
jmp 0xb421
movq %r15, (%rbx)
jmp 0xb448
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_O2/singpolyma[P]mnemonicode/mnemonic.c
// Function: mn_encode
int
mn_encode (void *src, int srcsize, char *dest, int destsize, char *format)
{
  int n;
  char *fmt;
  char *destend = dest + destsize;
  const char *word;

  if (format == 0 || format[0] == '\0')
    format = MN_FDEFAULT;
  fmt = format;
  for (n = 0; n < mn_words_required (srcsize); n++)
    {
      while (dest < destend && *fmt != '\0' && !isalpha (*fmt))
	*dest++ = *fmt++;
      if (dest >= destend)
	return MN_EOVERRUN;
      if (*fmt == '\0')
	{
	  if (isalpha (fmt[-1]) && isalpha (format[0]))
	    return MN_EFORMAT;
	  fmt = format;
	  while (dest < destend && *fmt != '\0' && !isalpha (*fmt))
	    *dest++ = *fmt++;
	  if (!isalpha (*fmt))
	    return MN_EFORMAT;
	}
      word = mn_encode_word (src, srcsize, n);
      if (word == 0)
	return MN_EOVERRUN;	/* shouldn't happen, actually */

      while (isalpha (*fmt))
	fmt++;
      while (dest < destend && *word != '\0')
	*dest++ = *word++;
    }
  if (dest < destend)
    *dest++ = '\0';
  else
    return MN_EOVERRUN;
  return MN_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, 0x10(%rsp)
movslq %ecx, %r15
testq %r8, %r8
je 0xb5ea
movq %r8, %r14
cmpb $0x0, (%r8)
jne 0xb5f1
leaq 0xa4f(%rip), %r14       # 0xc040
addq %rbx, %r15
movq (%rsp), %rax
leal (%rax,%rax,2), %eax
addl $0x3, %eax
pushq $0x4
popq %rcx
cltd
idivl %ecx
movl %eax, %r13d
xorl %ebp, %ebp
testl %eax, %eax
cmovlel %ebp, %r13d
movq %r14, 0x8(%rsp)
cmpl %r13d, %ebp
je 0xb703
cmpq %r15, %rbx
jae 0xb6f1
movsbq (%r14), %r12
callq 0xb080
movq (%rax), %rcx
testq %r12, %r12
je 0xb64a
testb $0x4, 0x1(%rcx,%r12,2)
jne 0xb6a1
incq %r14
movb %r12b, (%rbx)
incq %rbx
jmp 0xb61d
movsbq -0x1(%r14), %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
movq 0x8(%rsp), %r14
je 0xb66a
movsbq (%r14), %rdx
testb $0x4, 0x1(%rcx,%rdx,2)
jne 0xb712
cmpq %r15, %rbx
jae 0xb68c
movsbq (%r14), %rcx
movq (%rax), %rdx
testq %rcx, %rcx
je 0xb694
testb $0x4, 0x1(%rdx,%rcx,2)
jne 0xb696
incq %r14
movb %cl, (%rbx)
incq %rbx
jmp 0xb66a
movq (%rax), %rdx
movb (%r14), %cl
jmp 0xb696
xorl %ecx, %ecx
movsbq %cl, %rax
testb $0x4, 0x1(%rdx,%rax,2)
je 0xb712
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl %ebp, %edx
callq 0xb324
testq %rax, %rax
je 0xb6f1
movq %rax, %r12
callq 0xb080
movq (%rax), %rax
decq %r14
movsbq 0x1(%r14), %rcx
incq %r14
testb $0x4, 0x1(%rax,%rcx,2)
jne 0xb6c4
jmp 0xb6dd
incq %r12
movb %al, (%rbx)
incq %rbx
cmpq %r15, %rbx
jae 0xb6ea
movb (%r12), %al
testb %al, %al
jne 0xb6d5
incl %ebp
jmp 0xb614
pushq $-0x2
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %r15, %rbx
pushq $-0x2
popq %rax
jae 0xb6f4
movb $0x0, (%rbx)
xorl %eax, %eax
jmp 0xb6f4
pushq $-0x8
jmp 0xb6f3
// File: /workspace/github_c_makefile_star2_O2/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), %r15
movq %rdi, (%r15)
leaq 0xc(%rsp), %r12
andl $0x0, (%r12)
movq %r15, %rdi
callq 0xb339
testl %eax, %eax
je 0xb755
movl %eax, %edi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0xb459
jmp 0xb738
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xb764
pushq $-0x7
popq %rax
jmp 0xb77d
leaq 0xc(%rsp), %rcx
xorl %edi, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb459
testl %eax, %eax
js 0xb77d
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %eax, %eax
xorl %edx, %edx
cmpl $0x4, %edx
je 0x13cb
btl %edx, %esi
movzbl %dil, %edi
movl %edi, %r8d
cmovael %ecx, %r8d
xorb %al, %r8b
leal (%rdi,%rdi), %eax
movzbl %al, %r9d
xorb $0x3, %al
testb $0x8, %dil
movzbl %al, %edi
cmovel %r9d, %edi
incl %edx
movl %r8d, %eax
jmp 0x139a
andb $0xf, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13fb
cmpq $0x4, %rax
je 0x1446
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x13ee
movb (%rsi,%rcx), %dl
xorb %dl, (%rdi,%rcx)
incq %rcx
jmp 0x13dd
incq %rax
addq $0x4, %rsi
addq $0x4, %rdi
jmp 0x13d5
movq 0x2bee(%rip), %rcx      # 0x3ff0
cmpq $0x4, %rax
je 0x1446
leaq (,%rax,4), %rdx
xorl %r8d, %r8d
cmpq $0x4, %r8
je 0x143d
xorl %r9d, %r9d
cmpl $0x41, (%rcx)
setge %r9b
shll $0x4, %r9d
movl %edx, %r10d
orl %r8d, %r10d
orl %r9d, %r10d
movb (%rsi,%r10), %r9b
xorb %r9b, (%rdi,%r8)
incq %r8
jmp 0x1413
incq %rax
addq $0x4, %rdi
jmp 0x1402
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ba2(%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 0xbac(%rip), %rcx       # 0x2030
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_O2/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: SubCell
void SubCell(unsigned char state[4][4])
{
	int i,j;
	for(i = 0; i < 4; i++)
		for(j = 0; j <  4; j++)
			state[i][j] = sbox[state[i][j]];
}

// Assembly:
xorl %eax, %eax
movq 0x2b51(%rip), %rcx      # 0x3ff8
cmpq $0x4, %rax
je 0x14cf
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x14c6
movzbl (%rdi,%rdx), %esi
movb (%rcx,%rsi), %sil
movb %sil, (%rdi,%rdx)
incq %rdx
jmp 0x14af
incq %rax
addq $0x4, %rdi
jmp 0x14a7
retq
// File: /workspace/github_c_makefile_star2_O2/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
movabsq $0x1, %rax
cmpq $0x4, %rax
je 0x151b
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x14f8
movb (%rdi,%rcx), %dl
movb %dl, -0x4(%rsp,%rcx)
incq %rcx
jmp 0x14e6
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x1512
leal (%rax,%rcx), %edx
andl $0x3, %edx
movb -0x4(%rsp,%rdx), %dl
movb %dl, (%rdi,%rcx)
incq %rcx
jmp 0x14fa
incq %rax
addq $0x4, %rdi
jmp 0x14de
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x158e
movq 0x2a96(%rip), %r12      # 0x3fd0
xorl %r13d, %r13d
cmpq $0x4, %r13
je 0x1572
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq $0x4, %rbp
je 0x1564
movzbl (%r12,%rbp), %edi
movzbl (%rbx,%rbp,4), %esi
callq 0x1090
xorb %al, %r15b
incq %rbp
jmp 0x1548
movb %r15b, 0x4(%rsp,%r13)
incq %r13
addq $0x4, %r12
jmp 0x153d
xorl %eax, %eax
cmpq $0x4, %rax
je 0x1586
movb 0x4(%rsp,%rax), %cl
movb %cl, (%rbx,%rax,4)
incq %rax
jmp 0x1574
incq %r14
incq %rbx
jmp 0x152d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/led80n6t4silcv2/ref/led.c
// Function: LED_enc
void LED_enc(unsigned char* input, const unsigned char* userkey, int ksbits)
{
#ifdef _PRINT
	printf("LED  input: ");
	pstate(input, 8);
#endif
	unsigned char state[4][4];
	unsigned char keyNibbles[32];
	int i;
	for(i = 0; i < 16; i++) {
		if(i%2) state[i/4][i%4] = input[i>>1]&0xF;
		else state[i/4][i%4] = (input[i>>1]>>4)&0xF;
	}

	/* break the key into 4-bit nibbles */
	memset(keyNibbles, 0, 32);
	for(i = 0; i < ksbits/4; i++){
		if(i%2) keyNibbles[i] = userkey[i>>1]&0xF;
		else keyNibbles[i] = (userkey[i>>1]>>4)&0xF;
	}
	LED = ksbits;
	int RN = 48;
	if(LED <= 64)
		RN = 32;
	int j;
	AddKey(state, keyNibbles, 0);
	for(i = 0; i < RN/4; i++){
		for(j = 0; j < 4; j++)
		{
			AddConstants(state, i*4+j);
			SubCell(state);
			ShiftRow(state);
			MixColumn(state);
		}
		AddKey(state, keyNibbles, i+1);
	}
	for(i = 0; i < 8; i++)
		input[i] = ((state[(2*i)/4][(2*i)%4] & 0xF) << 4) | (state[(2*i+1)/4][(2*i+1)%4] & 0xF);
#ifdef _PRINT
	printf("LED output: ");
	pstate(input, 8);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ecx
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x10, %eax
je 0x15f2
movl %eax, %edx
shrl %edx
movb (%rbx,%rdx), %dl
movl %edx, %edi
andb $0xf, %dil
shrb $0x4, %dl
testb $0x1, %al
movzbl %dl, %edx
movzbl %dil, %edi
cmovel %edx, %edi
movl %eax, %edx
andl $0x3, %edx
movl %eax, %r8d
andl $-0x4, %r8d
addq %rsp, %r8
movb %dil, (%rdx,%r8)
incl %eax
jmp 0x15ba
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x10(%rsp)
pushq $0x4
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
movl %eax, %edx
sarl $0x1f, %edx
andnl %eax, %edx, %eax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x1641
movl %edx, %edi
shrl %edi
movb (%rsi,%rdi), %dil
movl %edi, %r8d
shrb $0x4, %r8b
andb $0xf, %dil
testb $0x1, %dl
movzbl %r8b, %r8d
movzbl %dil, %edi
cmovel %r8d, %edi
movb %dil, 0x10(%rsp,%rdx)
incq %rdx
jmp 0x1610
movq 0x29a8(%rip), %rax      # 0x3ff0
movl %ecx, (%rax)
xorl %r15d, %r15d
cmpl $0x41, %ecx
setge %r15b
movq %rsp, %r14
leaq 0x10(%rsp), %rsi
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
vzeroupper
callq 0x10b0
leal 0x8(,%r15,4), %r13d
xorl %ebp, %ebp
cmpl %r13d, %ebp
je 0x16c4
xorl %r15d, %r15d
cmpl $0x4, %r15d
je 0x16ad
leal (%r12,%r15), %esi
movq %r14, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1130
movq %r14, %rdi
callq 0x10d0
incl %r15d
jmp 0x167e
incl %ebp
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movl %ebp, %edx
callq 0x10b0
addl $0x4, %r12d
jmp 0x1676
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x16f8
movl %ecx, %edx
shrl %edx
movl %eax, %esi
andl $0x2, %esi
leaq (%rsp,%rdx,4), %rdx
movb (%rsi,%rdx), %dil
shlb $0x4, %dil
movb 0x1(%rdx,%rsi), %dl
andb $0xf, %dl
orb %dil, %dl
movb %dl, (%rbx,%rcx)
incq %rcx
addl $0x2, %eax
jmp 0x16c8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %r8, 0x38(%rdi)
andq $0x0, (%rdi)
movq %rdi, %rax
subq %r8, %rax
movb $-0x38, 0x7(%rax)
addq $0x8, %rdi
movq %rdi, (%rsp)
subq %r8, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x1120
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1100
movq %r14, %r15
shrq $0x3, %r15
pushq $0x8
popq %rbp
movq %r12, %r13
subq $0x1, %r15
jb 0x17a5
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x10f0
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1100
addq $0x8, %r13
jmp 0x1780
movq %r14, %rdx
andq $0x7, %rdx
je 0x17cf
movq %r14, %rax
andq $-0x8, %rax
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10f0
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1100
pushq $0x8
popq %rcx
movq %rcx, %rax
subq $0x1, %rax
jb 0x17e9
xorb %r14b, -0x1(%rbx,%rcx)
shrq $0x8, %r14
movq %rax, %rcx
jmp 0x17d5
movb (%rbx), %al
movb 0x1(%rbx), %cl
pushq $0x1
popq %rdx
cmpq $0x8, %rdx
je 0x1805
movb (%rbx,%rdx), %sil
movb %sil, -0x1(%rbx,%rdx)
incq %rdx
jmp 0x17f1
xorb %al, %cl
movb %cl, 0x7(%rbx)
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1100
movb 0x8(%rbx), %al
movb 0x9(%rbx), %cl
xorl %edx, %edx
cmpq $0x7, %rdx
je 0x183a
movb 0x9(%rbx,%rdx), %sil
movb %sil, 0x8(%rbx,%rdx)
incq %rdx
jmp 0x1825
xorb %al, %cl
movb %cl, 0xf(%rbx)
movq 0x10(%rbx), %rsi
movq (%rsp), %rdi
callq 0x1100
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_O2/antonblanchard[P]will-it-scale/tests/futex2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		unsigned int addr = 0;

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

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
pushq $0x1
popq %rbp
andl $0x0, 0xc(%rsp)
andl $0x0, (%rsp)
movl $0xca, %edi
movq %r14, %rsi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x2150
incq (%rbx)
jmp 0x2b33
// File: /workspace/github_c_makefile_star2_O2/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 0x64e1
cmpl $0x64, %edi
je 0x64dd
cmpl $0x70, %edi
jne 0x64e7
pushq $0x1
popq %rdi
callq 0x6360
pushq $0x14
jmp 0x64e3
pushq $-0x14
popq %rax
addl %eax, 0x18(%rbx)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x7040
xorl %r14d, %r14d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
cmpl $0x1f4, %r14d           # imm = 0x1F4
je 0x651b
movq 0x20(%rbx), %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x6f00
addl $0x32, %r14d
jmp 0x64f6
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_O2/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
andq $0x0, 0x18(%rbx)
xorl %eax, %eax
callq 0x6710
movq %rax, %r14
movq %rax, (%rbx)
leaq 0x3aa8(%rip), %rcx      # 0xa004
pushq $0x32
popq %rdx
movq %rax, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x6a40
movq %rax, %r15
movq %rax, 0x8(%rbx)
leaq 0x3a8f(%rip), %rsi      # 0xa009
leaq -0x30(%rbp), %r12
leaq -0x2c(%rbp), %r13
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7b60
movq %rax, 0x10(%rbx)
leaq 0x3a7a(%rip), %rsi      # 0xa015
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7b60
movq %rax, 0x20(%rbx)
leaq -0xf8(%rip), %rsi       # 0x64bc
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6d30
movq (%rbx), %rdi
callq 0x6bc0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_05/calculator.c
// Function: main
int main(int argc, char *argv[])
{
  char c;
  double op2;
  char str[MAX_STR_LEN];

  while (scanf("%s", str) != EOF)
  {
    if (sscanf(str, "%lf", &op2) == 1)
    {
      push(op2);
    }
    else if (sscanf(str, "%c", &c) == 1)
    {
      switch (c)
      {
      case '+':
        push(pop() + pop());
        break;

      case '-':
        op2 = pop();
        push(pop() - op2);
        break;

      case '*':
        push(pop() * pop());
        break;

      case '/':
        op2 = pop();

        if (op2 != 0.0)
        {
          push(pop() / op2);
        }
        else
        {
          printf("Error: zero divisor.\n");
        }
        break;

      case '%':
        op2 = pop();

        if (op2 != 0.0)
        {
          push((int)pop() % (int)op2);
        }
        else
        {
          printf("Error: zero divisor.\n");
        }
        break;

      default:
        printf("Error: unknown command.\n");
        break;
      }
    }
  }

  printf("result: %.8g\n", pop());

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
leaq 0xeb8(%rip), %rbx       # 0x203c
leaq 0x20(%rsp), %r14
leaq 0xeaf(%rip), %r15       # 0x203f
leaq 0x10(%rsp), %r12
leaq 0xea7(%rip), %r13       # 0x2043
leaq 0xf(%rsp), %rbp
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
cmpl $-0x1, %eax
je 0x12f4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1050
cmpl $0x1, %eax
jne 0x11d9
movsd 0x10(%rsp), %xmm0
callq 0x131b
jmp 0x11a1
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1050
cmpl $0x1, %eax
jne 0x11a1
movzbl 0xf(%rsp), %eax
addl $-0x25, %eax
cmpl $0xa, %eax
ja 0x1246
leaq 0xe0e(%rip), %rcx       # 0x2010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x134c
movsd %xmm0, 0x10(%rsp)
ucomisd 0xdea(%rip), %xmm0      # 0x2008
jne 0x1226
jnp 0x12e3
callq 0x134c
cvttsd2si 0x10(%rsp), %ecx
cvttsd2si %xmm0, %eax
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
callq 0x131b
jmp 0x11a1
leaq 0xe3f(%rip), %rdi       # 0x208c
callq 0x1030
jmp 0x11a1
callq 0x134c
movsd %xmm0, 0x18(%rsp)
callq 0x134c
addsd 0x18(%rsp), %xmm0
callq 0x131b
jmp 0x11a1
callq 0x134c
movsd %xmm0, 0x18(%rsp)
callq 0x134c
mulsd 0x18(%rsp), %xmm0
callq 0x131b
jmp 0x11a1
callq 0x134c
movsd %xmm0, 0x10(%rsp)
callq 0x134c
subsd 0x10(%rsp), %xmm0
callq 0x131b
jmp 0x11a1
callq 0x134c
movsd %xmm0, 0x10(%rsp)
ucomisd 0xd3e(%rip), %xmm0      # 0x2008
jne 0x12ce
jnp 0x12e3
callq 0x134c
divsd 0x10(%rsp), %xmm0
callq 0x131b
jmp 0x11a1
leaq 0xd8d(%rip), %rdi       # 0x2077
callq 0x1030
jmp 0x11a1
callq 0x134c
leaq 0xd46(%rip), %rdi       # 0x2046
movb $0x1, %al
callq 0x1040
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $-0x1, %edi
je 0x137e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x1341
cvtsi2ss %edi, %xmm0
cvtsi2ssl (%rsi), %xmm1
divss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x12ea
sqrtss %xmm0, %xmm0
jmp 0x12ef
callq 0x1110
mulss 0xbd0d(%rip), %xmm0     # 0xd004
cvttss2si %xmm0, %ebp
cmpl %ebp, 0x130f3(%rip)     # 0x143f4
jge 0x1330
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
movq 0x12ce5(%rip), %r15     # 0x13ff8
pushq $0x3e
popq %rbx
movq (%r15), %rsi
subl $0x1, %r14d
jb 0x1328
movl %ebx, %edi
callq 0x10d0
jmp 0x1316
pushq $0xd
popq %rdi
callq 0x10d0
movl %ebp, 0x130be(%rip)     # 0x143f4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x12cb0(%rip), %r14     # 0x13ff8
movq (%r14), %rcx
leaq 0xbcde(%rip), %rdi      # 0xd030
pushq $0x19
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1190
movq (%r14), %rcx
leaq 0xcc6f(%rip), %rdi      # 0xdfd9
pushq $0x42
popq %rsi
movq %rbx, %rdx
callq 0x1190
andl $0x0, 0x13078(%rip)     # 0x143f4
jmp 0x1336
movq 0x12c73(%rip), %rax     # 0x13ff8
movq (%rax), %rcx
leaq 0xbcbb(%rip), %rdi      # 0xd04a
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/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
movl %eax, %ecx
xorl %r8d, %r8d
testl %eax, %eax
cmovgl %eax, %r8d
leal 0x1(%rax), %r9d
incl %r8d
movabsq $0x1, %r10
movq %r10, %r11
cmpq %r8, %r11
je 0x1da1
movq %r10, %rbx
cmpq %r11, %rbx
je 0x1d4b
movq 0x8(%rsi), %r12
movsd (%r12,%rbx,8), %xmm0
movq 0x8(%rdi), %r15
movq (%r15,%r11,8), %r14
mulsd (%r14,%rbx,8), %xmm0
movq (%r15,%rbx,8), %r15
divsd (%r15,%rbx,8), %xmm0
movsd (%r12,%r11,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r12,%r11,8)
movq %r10, %r12
cmpq %r12, %r9
je 0x1d46
movsd (%r14,%rbx,8), %xmm0
mulsd (%r15,%r12,8), %xmm0
divsd (%r15,%rbx,8), %xmm0
movsd (%r14,%r12,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r14,%r12,8)
incq %r12
jmp 0x1d1a
incq %rbx
jmp 0x1ce0
incq %r11
jmp 0x1cd4
movq 0x8(%rsi), %r8
movsd (%r8,%rcx,8), %xmm0
movq 0x8(%rdi), %r8
movq (%r8,%rcx,8), %r8
divsd (%r8,%rcx,8), %xmm0
movq 0x8(%rdx), %r9
movsd %xmm0, (%r9,%rcx,8)
movl %eax, %r10d
cmpl %ecx, %r10d
jle 0x1d9e
movl %r10d, %r11d
movsd (%r8,%r11,8), %xmm1
mulsd (%r9,%r11,8), %xmm1
divsd (%r8,%rcx,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r9,%rcx,8)
decl %r10d
jmp 0x1d75
decq %rcx
testl %ecx, %ecx
jg 0x1d50
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb25f(%rip), %rdi      # 0xdad4
callq 0x1060
leaq 0xaf36(%rip), %rdi      # 0xd7b7
callq 0x1060
leaq 0xb2b7(%rip), %rdi      # 0xdb44
callq 0x1060
leaq 0xaf49(%rip), %rdi      # 0xd7e2
callq 0x1060
leaq 0xb270(%rip), %rdi      # 0xdb15
callq 0x1060
leaq 0xaf68(%rip), %rdi      # 0xd819
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xad45
movq %rax, %rbx
leaq 0xabcc(%rip), %r14      # 0xd498
testq %rbx, %rbx
je 0x28ee
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
jmp 0x28cc
leaq 0xaf32(%rip), %rdi      # 0xd827
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0xb1c5(%rip), %rdi      # 0xdad4
callq 0x1060
leaq 0xaf1a(%rip), %rdi      # 0xd835
callq 0x1060
leaq 0xb21d(%rip), %rdi      # 0xdb44
callq 0x1060
leaq 0xaf2b(%rip), %rdi      # 0xd85e
callq 0x1060
leaq 0xb1d6(%rip), %rdi      # 0xdb15
callq 0x1060
leaq 0xafbc(%rip), %rdi      # 0xd907
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %rbx
leaq 0xab44(%rip), %r14      # 0xd4aa
testq %rbx, %rbx
je 0x298d
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
jmp 0x2966
leaq 0xaf04(%rip), %rdi      # 0xd898
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0xb126(%rip), %rdi      # 0xdad4
callq 0x1060
leaq 0xaef6(%rip), %rdi      # 0xd8b0
callq 0x1060
leaq 0xb17e(%rip), %rdi      # 0xdb44
callq 0x1060
leaq 0xaf0d(%rip), %rdi      # 0xd8df
callq 0x1060
leaq 0xb137(%rip), %rdi      # 0xdb15
callq 0x1060
leaq 0xaf17(%rip), %rdi      # 0xd901
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %rbx
leaq 0xaaa5(%rip), %r14      # 0xd4aa
testq %rbx, %rbx
je 0x2a3b
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
jmp 0x2a05
leaq 0xaed8(%rip), %rdi      # 0xd91a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0xb078(%rip), %rdi      # 0xdad4
callq 0x1060
leaq 0xaed0(%rip), %rdi      # 0xd938
callq 0x1060
leaq 0xb0d0(%rip), %rdi      # 0xdb44
callq 0x1060
leaq 0xb0ce(%rip), %rdi      # 0xdb4e
callq 0x1060
leaq 0xb089(%rip), %rdi      # 0xdb15
callq 0x1060
leaq 0xb0ec(%rip), %rdi      # 0xdb84
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %rbx
leaq 0xa9f7(%rip), %r14      # 0xd4aa
testq %rbx, %rbx
je 0x2ada
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
jmp 0x2ab3
leaq 0xae7c(%rip), %rdi      # 0xd95d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0xa7f7(%rip), %rdi      # 0xdad4
callq 0x1060
leaq 0xa82e(%rip), %rdi      # 0xdb17
callq 0x1060
leaq 0xa84f(%rip), %rdi      # 0xdb44
callq 0x1060
leaq 0xa84d(%rip), %rdi      # 0xdb4e
callq 0x1060
leaq 0xa808(%rip), %rdi      # 0xdb15
callq 0x1060
leaq 0xa863(%rip), %rdi      # 0xdb7c
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %rbx
leaq 0xa241(%rip), %r14      # 0xd575
testq %rbx, %rbx
je 0x3366
cmpl $0xf, 0x14(%rbx)
jne 0x3360
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
jmp 0x3334
leaq 0xa826(%rip), %rdi      # 0xdb93
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movl 0x18(%rbx), %edx
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0xc14c
xorl %r15d, %r15d
cmpl $0xf, 0x14(%rax)
sete %r15b
movq (%r14), %rdi
movl 0x1c(%rbx), %edx
movl %ebp, %esi
callq 0xc14c
leal 0x1(%r15), %r12d
cmpl $0xf, 0x14(%rax)
cmovnel %r15d, %r12d
movq (%r14), %rdi
movl 0x20(%rbx), %edx
movl %ebp, %esi
callq 0xc14c
xorl %ecx, %ecx
cmpl $0xf, 0x14(%rax)
sete %cl
addl %r12d, %ecx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xad45
movq %rax, %r15
testq %r15, %r15
je 0x3431
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3379
cmpl $0x2, %eax
jne 0x342b
movl 0x10(%r14), %eax
cmpl %eax, 0x18(%r15)
je 0x3429
cmpl %eax, 0x1c(%r15)
je 0x3429
cmpl %eax, 0x20(%r15)
jne 0x342b
incl %ebp
movq 0x8(%r15), %r15
jmp 0x33fe
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq (%r8), %rdi
movl 0x18(%r15), %edx
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0xc14c
movsd 0x38(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%r14), %rdi
movl 0x1c(%r15), %edx
movl %ebp, %esi
callq 0xc14c
movq (%r14), %rdi
movl 0x20(%r15), %edx
movsd (%rsp), %xmm0
addsd 0x38(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
addsd 0x40(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movl %ebp, %esi
callq 0xc14c
movsd (%rsp), %xmm1
addsd 0x38(%rax), %xmm1
movsd 0x9f65(%rip), %xmm0     # 0xd450
mulsd %xmm0, %xmm1
mulsd 0xb8(%r15), %xmm1
mulsd 0x30(%r14), %xmm1
movapd %xmm1, %xmm3
movsd 0x8(%rsp), %xmm2
addsd 0x40(%rax), %xmm2
movsd 0x10(%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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%r8), %rdi
movl 0x18(%r13), %edx
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0xc14c
movsd 0x38(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%r14), %rdi
movl 0x1c(%r13), %edx
movl %ebp, %esi
callq 0xc14c
movq (%r14), %rdi
movl 0x20(%r13), %edx
movsd (%rsp), %xmm0
addsd 0x38(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
addsd 0x40(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movl %ebp, %esi
callq 0xc14c
movsd (%rsp), %xmm1
addsd 0x38(%rax), %xmm1
movsd 0x9e46(%rip), %xmm0     # 0xd450
mulsd %xmm0, %xmm1
mulsd 0x30(%r14), %xmm1
movapd %xmm1, %xmm3
movsd 0x8(%rsp), %xmm2
addsd 0x40(%rax), %xmm2
movsd 0x10(%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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x993f(%rip), %rdi      # 0xdda0
callq 0x1060
leaq 0x9820(%rip), %rdi      # 0xdc8d
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc14c
movq %rax, %rbx
leaq 0x91cb(%rip), %r14      # 0xd653
leaq 0x91e2(%rip), %r15      # 0xd671
testq %rbx, %rbx
je 0x44c3
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
jmp 0x448f
leaq 0x98d6(%rip), %rdi      # 0xdda0
popq %rbx
popq %r14
popq %r15
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x98b6(%rip), %rdi      # 0xdda0
callq 0x1060
leaq 0x979e(%rip), %rdi      # 0xdc94
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xad45
movq %rax, %rbx
leaq 0x917d(%rip), %r14      # 0xd68e
pushq $0x5b
popq %rbp
pushq $0x1
popq %r15
leaq 0x917b(%rip), %r12      # 0xd69a
testq %rbx, %rbx
je 0x455d
movl 0x10(%rbx), %r9d
movl 0x14(%rbx), %esi
movl $0x3, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %ecx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x1090
movl 0x20(%rbx), %edx
movl 0x18(%rbx), %esi
movl 0x1c(%rbx), %ecx
movq %r12, %rdi
xorl %eax, %eax
callq 0x1090
movq 0x8(%rbx), %rbx
jmp 0x451f
leaq 0x983c(%rip), %rdi      # 0xdda0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1060