LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/System-Glitch[P]ESGILinter-C/src/parsing_functions.c
// Function: check_function_call_parameters
void check_function_call_parameters(scope_t *scope, function_t *call, function_t *function, int line_index, messages_t *messages) {
	field_t *field            = NULL;
	field_t *param            = NULL;
	invalid_call_t *error     = NULL;
	type_t type;

	if(function != NULL && call->params->size != function->params->size && messages->invalid_calls != NULL) {
		error = malloc(sizeof(invalid_call_t));
		error->name = strduplicate(function->name);
		error->more = call->params->size - function->params->size;
		arraylist_add(messages->invalid_calls, error);
	}

	for(size_t i = 0 ; i < call->params->size ; i++) {

		field = arraylist_get(call->params, i);

		type = parse_expression(field->name, line_index, scope, messages);
		if(!strcmp(type.name, "NULL")) {
			type = parse_operation(field->name, line_index, scope, messages);
		}

		if(function != NULL && i < function->params->size) {
			param = arraylist_get(function->params, i);
			if(strcmp(type.name, "NULL") && !type_equals(&type, &(param->type))) {
				arraylist_add(messages->invalid_params, field_init(strduplicate(field->name), strduplicate(field->type.name), field->type.is_pointer, field->line));
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0xb551
movq 0x20(%r12), %rax
movq 0x8(%rax), %rax
movq 0x20(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0xb551
cmpq $0x0, 0x18(%rbx)
je 0xb551
movl $0x10, %edi
callq 0x2140
movq %rax, %r15
movq (%r14), %rdi
callq 0x7d58
movq %rax, (%r15)
movq 0x20(%r12), %rax
movl 0x8(%rax), %eax
movq 0x20(%r14), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0x8(%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x6b96
movq 0x20(%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0xb652
xorl %r13d, %r13d
movq %r13, %rsi
callq 0x6c76
movq %rax, %r15
movq (%rax), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0xb680
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, %rdi
leaq 0x3329(%rip), %rsi      # 0xe8c0
callq 0x2120
testl %eax, %eax
jne 0xb5be
movq (%r15), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x7020
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
testq %r14, %r14
je 0xb640
movq 0x20(%r14), %rdi
cmpq 0x8(%rdi), %r13
jae 0xb640
movq %r13, %rsi
callq 0x6c76
movq %rax, %rbp
movq 0x10(%rsp), %rdi
leaq 0x32dc(%rip), %rsi      # 0xe8c0
callq 0x2120
testl %eax, %eax
je 0xb640
addq $0x10, %rbp
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x67b4
testb %al, %al
jne 0xb640
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movq (%r15), %rdi
callq 0x7d58
movq %rax, %rbp
movq 0x10(%r15), %rdi
callq 0x7d58
movsbl 0x18(%r15), %edx
movl 0x20(%r15), %ecx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x6090
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x6b96
incq %r13
movq 0x20(%r12), %rdi
cmpq 0x8(%rdi), %r13
jb 0xb564
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/System-Glitch[P]ESGILinter-C/src/parsing_expressions.c
// Function: find_semi_colon
static int find_semi_colon(char *line, int index, int length) {
	int sc_index = strindexof(line + index,  ';') + index;

	if(sc_index != -1 && check_quotes(line, line + sc_index, length)) {
		return find_semi_colon(line, sc_index + 1, length);
	}

	return sc_index;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movslq %ebx, %rbx
leaq (%r14,%rbx), %rdi
movl $0x3b, %esi
callq 0x7f51
addl %eax, %ebx
cmpl $-0x1, %ebx
je 0xc9ef
movslq %ebx, %rsi
addq %r14, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x8291
testb %al, %al
je 0xc9ef
incl %ebx
jmp 0xc9bf
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: defineSymbol
SYM_T *defineSymbol( char *name, WORD32 val, SYMTYP type, WORD32 start )
{
  SYM_T  *sym;
  WORD32  xref_count;

  val = val & 07777;
  if( strlen( name ) < 1 )
  {
    return( &sym_undefined );   /* Protect against non-existent names.        */
  }
  sym = lookup( name );
  xref_count = 0;               /* Set concordance for normal defintion.      */

  if( M_DEFINED( sym->type ) && sym->val != val && M_NOTRDEF( sym -> type ))
  {
    if( pass == 2 )
    {
      errorSymbol( &redefined_symbol, sym->name, start );
      type = type | REDEFINED;
      sym->xref_count++;      /* Referenced symbol, count it.                */
      xref_count = sym->xref_count;
    }
  return ( sym );
  }
  if( M_FIXED( sym->type ))
  {
  return ( sym );
  }

  if( pass == 2 && xref )
  {
    /* Put the definition line number in the concordance table.               */
    /* Defined symbols are not counted as references.                         */
    xreftab[sym->xref_index] = lineno;
    /* Put the line number in the concordance table.                          */
    xreftab[sym->xref_index + xref_count] = lineno;
  }

  /* Now set the value and the type.                                          */
  sym->val = val;
  sym->type = ( pass == 1 ) ? ( type | CONDITION ) : type;
  return( sym );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x2bc6
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
andl $0xfff, %r14d           # imm = 0xFFF
callq 0x40f1
movq %rax, %rbx
movl (%rax), %eax
testb $0x1, %al
jne 0x2bdb
testb $0x2, %al
jne 0x2bcd
cmpq $0x2, 0xb1ad(%rip)      # 0xdd30
jne 0x2bac
cmpb $0x0, 0x910a(%rip)      # 0xbc96
je 0x2bac
movslq 0x14c67(%rip), %rax     # 0x177fc
movq 0x132f4(%rip), %rcx     # 0x15e90
movq 0x18(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x18(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq %r14, 0x10(%rbx)
movl %ebp, %eax
orl $0x80, %eax
cmpq $0x1, 0xb171(%rip)      # 0xdd30
cmovnel %ebp, %eax
movl %eax, (%rbx)
jmp 0x2bcd
leaq 0x908b(%rip), %rbx      # 0xbc58
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl $0x14e, %eax            # imm = 0x14E
je 0x2b77
cmpq %r14, 0x10(%rbx)
je 0x2b77
cmpq $0x2, 0xb140(%rip)      # 0xdd30
jne 0x2bcd
movq %rbx, %rsi
addq $0x4, %rsi
leaq 0x8e50(%rip), %rdi      # 0xba50
movq %r15, %rdx
callq 0x42a8
incq 0x20(%rbx)
jmp 0x2bcd
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchLeader
void punchLeader( WORD32 count )
{
  WORD32  ix;

  /* If value is zero, set to the default of 2 feet of leader.                */
  count = ( count == 0 ) ? 240 : count;

  if( objectfile != NULL )
  {
    for( ix = 0; ix < count; ix++ )
    {
      fputc( 0200, objectfile );
    }
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
movl $0xf0, %ebx
cmovneq %rdi, %rbx
cmpq $0x0, 0x12c91(%rip)     # 0x15df0
sete %al
testq %rbx, %rbx
setle %cl
orb %al, %cl
jne 0x3182
movq 0x12c7d(%rip), %rsi     # 0x15df0
movl $0x80, %edi
callq 0x20e0
decq %rbx
jne 0x316c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: printMemoryMap
void printMemoryMap()
{
  WORD32 loc;
  int i, j, k;

  page_lineno = 0;
  list_lineno = 0;

  /* loop from loc 0 to maximum address used */
  for( loc = 0; loc <= memory_max; )
  {

    /* force a new page halfway thru the field */
    if( (loc & 03777) == 00000 ) page_lineno = LIST_LINES_PER_PAGE;
    if( page_lineno >= LIST_LINES_PER_PAGE )
    {
      topOfForm( list_title, s_memmap );
    }

    /* print two halves of a page over two lines */
    for( i = 0; i < 2; ++i )
    {
      page_lineno++;
      list_lineno++;
      fprintf( listfile, "%5d %05o/", list_lineno, (unsigned)loc );
      /* print 8 groups per line */
      for( j = 0; j < 8; ++j )
      {
	fprintf( listfile, " " );
	/* print 8 words per group */
	for( k = 0; k < 8; ++k )
	{
	  fprintf( listfile, "%c", memory_map[loc++] ? 'X' : '.');
	}
      }
      fprintf( listfile, "\n" );
    }

    page_lineno++;
    list_lineno++;
    fprintf( listfile, "%5d\n", list_lineno );
  }

}

// Assembly:
xorl %eax, %eax
movl %eax, 0x1415b(%rip)     # 0x1780c
movl %eax, 0x1414d(%rip)     # 0x17804
cmpq $0x0, 0x12699(%rip)     # 0x15d58
js 0x37e9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x428b(%rip), %r15      # 0x7962
leaq 0xa672(%rip), %rbp      # 0xdd50
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x35, %rax
jne 0x36f4
movl $0x3c, 0x14118(%rip)    # 0x1780c
cmpl $0x3c, 0x14111(%rip)    # 0x1780c
jl 0x3710
leaq 0x1495c(%rip), %rdi     # 0x18060
leaq 0x8265(%rip), %rsi      # 0xb970
callq 0x68dd
xorl %ebx, %ebx
incl 0x140f4(%rip)           # 0x1780c
movl 0x140e6(%rip), %edx     # 0x17804
incl %edx
movl %edx, 0x140de(%rip)     # 0x17804
movq 0x12753(%rip), %rdi     # 0x15e80
movq %r15, %rsi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2120
xorl %r14d, %r14d
movq 0x1273c(%rip), %rsi     # 0x15e80
movl $0x20, %edi
callq 0x20e0
movl $0x8, %r12d
movq 0x12725(%rip), %rsi     # 0x15e80
cmpb $0x0, (%r13,%rbp)
movl $0x2e, %edi
je 0x376d
movl $0x58, %edi
incq %r13
callq 0x20e0
decl %r12d
jne 0x3754
incl %r14d
cmpl $0x8, %r14d
jne 0x373d
movq 0x126f6(%rip), %rsi     # 0x15e80
movl $0xa, %edi
callq 0x20e0
leal 0x1(%rbx), %eax
testl %ebx, %ebx
movl %eax, %ebx
je 0x3712
incl 0x14065(%rip)           # 0x1780c
movl 0x14057(%rip), %edx     # 0x17804
incl %edx
movl %edx, 0x1404f(%rip)     # 0x17804
movq 0x126c4(%rip), %rdi     # 0x15e80
leaq 0x41a9(%rip), %rsi      # 0x796c
xorl %eax, %eax
callq 0x2120
leaq -0x1(%r13), %rax
cmpq 0x12583(%rip), %rax     # 0x15d58
jl 0x36e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: nextLexeme
void nextLexeme()
{
  /* Save start column of previous lexeme for diagnostic messages.            */
  lexstartprev = lexstart;
  lextermprev = lexterm;

  while( is_blank( line[cc] )) { cc++; }
  lexstart = cc;

  if( is_alnum( line[cc] ))
  {
    while( is_alnum( line[cc] )) { cc++; }
  }
  else if( is_end( line[cc] ))
  {
    /* End-of-Line, don't advance cc!                                         */
  }
  else
  {
    switch( line[cc] )
    {
    case '"':     /* Quoted letter                                            */
      if( cc + 2 < maxcc )
      {
        cc++;
        cc++;
      }
      else
      {
        errorMessage( &no_literal_value, lexstart );
        cc++;
      }
      break;

    case '/':     /* Comment, don't advance cc!                               */
      break;

    default:      /* All other punctuation.                                   */
      cc++;
      break;
    }
  }
  lexterm = cc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x14147(%rip), %rax     # 0x17c08
movq %rax, 0x14160(%rip)     # 0x17c28
movq 0x14149(%rip), %rax     # 0x17c18
movq %rax, 0x16b52(%rip)     # 0x1a628
movq 0x14153(%rip), %rbx     # 0x17c30
leaq 0x13d3c(%rip), %r14     # 0x17820
movabsq $0x4000000100001200, %rax # imm = 0x4000000100001200
movzbl (%rbx,%r14), %ecx
cmpq $0x3e, %rcx
ja 0x3b0b
btq %rcx, %rax
jae 0x3b0b
incq %rbx
movq %rbx, 0x14127(%rip)     # 0x17c30
jmp 0x3aee
movsbq %cl, %r15
movq %rbx, 0x140f2(%rip)     # 0x17c08
callq 0x21a0
movq (%rax), %rcx
testb $0x8, (%rcx,%r15,2)
jne 0x3b39
movzbl %r15b, %eax
cmpl $0x21, %eax
jg 0x3b5c
testl %eax, %eax
je 0x3b9b
cmpl $0xa, %eax
je 0x3b9b
jmp 0x3b8e
movq 0x140f0(%rip), %rax     # 0x17c30
movsbq (%rax,%r14), %rdx
testb $0x8, (%rcx,%rdx,2)
je 0x3b9b
movsbq 0x1(%rax,%r14), %rdx
incq %rax
testb $0x8, (%rcx,%rdx,2)
jne 0x3b4b
jmp 0x3b94
cmpl $0x2f, %eax
je 0x3b9b
cmpl $0x22, %eax
jne 0x3b8e
leaq 0x2(%rbx), %rax
cmpq 0x144c7(%rip), %rax     # 0x18038
jl 0x3b94
leaq 0x7f76(%rip), %rdi      # 0xbaf0
movq %rbx, %rsi
callq 0x5bd7
movq 0x140a7(%rip), %rax     # 0x17c30
incq %rax
jmp 0x3b94
incq %rbx
movq %rbx, %rax
movq %rax, 0x14095(%rip)     # 0x17c30
movq 0x1408e(%rip), %rax     # 0x17c30
movq %rax, 0x1406f(%rip)     # 0x17c18
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: endOfBinary
void endOfBinary()
{
  /* Points to end of page for () operands.                                   */
  punchLiteralPool( &cp, clc - 1 );
  /* Points to end of page zero for [] operands.                              */
  punchLiteralPool( &pz, field );
  if( error_in_line )
  listLine();             /* List line if not done yet.                       */
  return;
}

// Assembly:
pushq %rax
movq 0x123f9(%rip), %rsi     # 0x15fb0
decq %rsi
leaq 0x1341f(%rip), %rdi     # 0x16fe0
callq 0x3e22
movq 0x123eb(%rip), %rsi     # 0x15fb8
leaq 0x13814(%rip), %rdi     # 0x173e8
callq 0x3e22
cmpb $0x0, 0x14030(%rip)     # 0x17c10
je 0x3be8
popq %rax
jmp 0x68b6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchLiteralPool
void punchLiteralPool( LPOOL_T *p, WORD32 lpool_page )
{
  WORD32  loc;
  WORD32  pageno;
  WORD32  tmplc;

  pageno  = GET_PAGE (lpool_page);
  lpool_page &= 07600;

  if(( lpool_page == 0 ) && ( p != &pz ))
  {
    return;                     /* Don't punch page 0 pool if not asked.     */
  }

  if( lit_loc[pageno] < lit_base[pageno] )
  {
    if( !rim_mode )
    {
      /* Put out origin if not in rim mode.                                   */
		punchOrigin( lit_loc[pageno] | lpool_page );
	 }
      /* Put the literals in the object file.                                 */
    for( loc = lit_loc[pageno]; loc < lit_base[pageno]; loc++ )
    {
      tmplc = loc + lpool_page;
      printLine( line, (field | tmplc), p->pool[loc], LOC_VAL );
      punchLocObject( tmplc, p->pool[loc] );
    }
    p->error = FALSE;
    lit_base[pageno] = lit_loc[pageno];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
andq $0xf80, %r12            # imm = 0xF80
sete %al
leaq 0x135a7(%rip), %rcx     # 0x173e8
cmpq %rcx, %rdi
setne %cl
testb %al, %cl
jne 0x3ef8
movq %rdi, %rbx
shrl $0x7, %esi
movzbl %sil, %r13d
leal (,%r13,8), %eax
leaq 0x12968(%rip), %r14     # 0x167d0
movq (%rax,%r14), %rdi
leaq 0x1215d(%rip), %r15     # 0x15fd0
cmpq (%rax,%r15), %rdi
jge 0x3ef8
cmpb $0x0, 0x7e14(%rip)      # 0xbc94
jne 0x3e8a
orq %r12, %rdi
callq 0x3f07
leal (,%r13,8), %eax
movq (%rax,%r14), %rbp
cmpq (%rax,%r15), %rbp
jge 0x3edc
movq %r15, %r14
leaq (%r12,%rbp), %r15
movq 0x1210e(%rip), %rsi     # 0x15fb8
orq %r15, %rsi
movq 0x8(%rbx,%rbp,8), %rdx
leaq 0x13967(%rip), %rdi     # 0x17820
movl $0x3, %ecx
callq 0x3f6b
movq 0x8(%rbx,%rbp,8), %rsi
movq %r15, %rdi
movq %r14, %r15
callq 0x6b33
incq %rbp
cmpq (%r14,%r13,8), %rbp
jl 0x3e9c
movq $0x0, (%rbx)
shll $0x3, %r13d
leaq 0x128e2(%rip), %rax     # 0x167d0
movq (%r13,%rax), %rax
movq %rax, (%r13,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: lexemeToName
char *lexemeToName( char *name, WORD32 from, WORD32 term )
{
  WORD32  to;

  to = 0;

  while( from < term && to < ( SYMLEN - 1 ))
  {
    name[to++] = to_upper( line[from++] );
  }

  while( to < SYMLEN )
  {
    name[to++] = '\0';
  }
  return( name );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdx, %rsi
jge 0x427b
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1(%rsi), %r12
xorl %ebp, %ebp
leaq (%r12,%rbp), %r13
leaq (%r15,%rbp), %rax
leaq 0x135c5(%rip), %rcx     # 0x17820
movsbl (%rcx,%rax), %edi
callq 0x2080
leaq 0x1(%rbp), %rcx
movb %al, (%rbx,%rbp)
cmpq %r14, %r13
jge 0x427d
cmpq $0x5, %rbp
movq %rcx, %rbp
jb 0x424c
jmp 0x427d
xorl %ecx, %ecx
cmpq $0x6, %rcx
ja 0x4296
leaq (%rbx,%rcx), %rdi
movl $0x7, %edx
subq %rcx, %rdx
xorl %esi, %esi
callq 0x20d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: errorSymbol
void errorSymbol( EMSG_T *mesg, char *name, WORD32 col )
{
  char   linecol[40]; // [12] to [40] donorth 2020-03-18
  char  *s;

  if( pass == 2 )
  {
    s = ( name == NULL ) ? "" : name ;
    errors++;
    sprintf( linecol, "(%d:%ld)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s \"%s\" at Loc = %5.5o\n",
	     filename, linecol, mesg->file, s, (unsigned)clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
cmpq $0x2, 0x9a80(%rip)      # 0xdd30
jne 0x4340
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x3565(%rip), %r15      # 0x7836
cmovneq %rsi, %r15
incl 0x9a4d(%rip)            # 0xdd28
movl 0x1351b(%rip), %edx     # 0x177fc
leaq 0x1(%rbx), %rcx
leaq 0x36a4(%rip), %rsi      # 0x7990
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x2170
movq 0x9a1e(%rip), %rdi      # 0xdd20
movq 0x8(%r14), %r8
movl 0x11ca4(%rip), %eax     # 0x15fb0
movl %eax, (%rsp)
leaq 0x3683(%rip), %rsi      # 0x7999
leaq 0x11c13(%rip), %rdx     # 0x15f30
movq %r12, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6f7f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movb $0x1, 0x138c9(%rip)     # 0x17c10
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: evalSymbol
SYM_T *evalSymbol()
{
  char   name[SYMLEN];
  SYM_T *sym;

  sym = lookup( lexemeToName( name, lexstart, lexterm ));

  sym->xref_count++;            /* Count the number of references to symbol.  */

  if( xref && pass == 2 )
  {
    /* Put the line number in the concordance table.                          */
    xreftab[sym->xref_index + sym->xref_count] = lineno;
  }

  return( sym );
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x13665(%rip), %rsi     # 0x17c08
movq 0x1366e(%rip), %rdx     # 0x17c18
leaq 0x9(%rsp), %rbx
movq %rbx, %rdi
callq 0x422d
movq %rbx, %rdi
callq 0x40f1
movq 0x20(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
cmpb $0x0, 0x76c4(%rip)      # 0xbc96
je 0x45f9
cmpq $0x2, 0x9754(%rip)      # 0xdd30
jne 0x45f9
movslq 0x13217(%rip), %rdx     # 0x177fc
movq 0x18(%rax), %rsi
shlq $0x3, %rsi
addq 0x1189c(%rip), %rsi     # 0x15e90
movq %rdx, 0x8(%rsi,%rcx,8)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: testZeroPool
BOOL testZeroPool( WORD32 value )
{
  WORD32 ix;
  WORD32 pageno;

  pageno = GET_PAGE( field );
  for ( ix = lit_loc[pageno]; ix < lit_base[pageno]; ix++ )
  {
    if( pz.pool[ix] == value ) return TRUE;
  }
  return FALSE;
}

// Assembly:
movl 0x10868(%rip), %ecx     # 0x15fb8
shrl $0x4, %ecx
andl $0x7f8, %ecx            # imm = 0x7F8
leaq 0x11070(%rip), %rax     # 0x167d0
movq (%rcx,%rax), %rax
leaq 0x10865(%rip), %rdx     # 0x15fd0
movq (%rcx,%rdx), %rcx
cmpq %rcx, %rax
jge 0x578a
leaq 0x11c6d(%rip), %rdx     # 0x173e8
cmpq %rdi, 0x8(%rdx,%rax,8)
je 0x578d
incq %rax
cmpq %rax, %rcx
jne 0x577b
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: errorMessage
void errorMessage( EMSG_T *mesg, WORD32 col )
{
  char   linecol[40]; // [12] to [40] donorth 2020-03-18

  if( pass == 2 )
  {
    errors++;
    sprintf( linecol, "(%d:%ld)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s at Loc = %5.5o\n",
	     filename, linecol, mesg->file, (unsigned)clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
cmpq $0x2, 0x8151(%rip)      # 0xdd30
jne 0x5c52
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incl 0x8132(%rip)            # 0xdd28
movl 0x11c00(%rip), %edx     # 0x177fc
leaq 0x1(%rsi), %rcx
leaq 0x1d89(%rip), %rsi      # 0x7990
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2170
movq 0x8105(%rip), %rdi      # 0xdd20
movq 0x8(%r14), %r8
movl 0x1038a(%rip), %r9d     # 0x15fb0
leaq 0x1d95(%rip), %rsi      # 0x79c2
leaq 0x102fc(%rip), %rdx     # 0x15f30
movq %r15, %rcx
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x6f7f
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x11fb7(%rip)     # 0x17c10
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: moveToEndOfLine
void moveToEndOfLine()
{
  while( !is_end( line[cc] )) cc++;
  lexstart = cc;
  lexterm = cc;
  lexstartprev = lexstart;
}

// Assembly:
movq 0x11fcf(%rip), %rax     # 0x17c30
leaq 0x11bb8(%rip), %rcx     # 0x17820
movzbl (%rax,%rcx), %edx
testl %edx, %edx
je 0x5c81
cmpl $0xa, %edx
je 0x5c81
incq %rax
movq %rax, 0x11fb1(%rip)     # 0x17c30
jmp 0x5c68
movq %rax, 0x11f80(%rip)     # 0x17c08
movq %rax, 0x11f89(%rip)     # 0x17c18
movq %rax, 0x11f92(%rip)     # 0x17c28
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: evalDubl
WORD32 evalDubl( WORD32 initial_value )
{
  WORD32  digit;
  WORD32  from;
  WORD32  dublvalue;
  WORD32  olddublvalue;

  overflow = FALSE;
  delimiter = line[lexterm];
  from = lexstart;
  dublvalue = initial_value;

  while( from < lexterm )
  {
    if( is_digit( line[from] ))
    {
      olddublvalue = dublvalue;
      digit = (WORD32)( line[from++] - '0' );
      dublvalue = dublvalue * 10 + digit;
      if( dublvalue < olddublvalue )
      {
        overflow = TRUE;
      }
    }
    else
    {
      errorLexeme( &not_a_number, from );
      dublvalue = 0;
      from = lexterm;
    }
  }
  return( dublvalue );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbp
movb $0x0, 0x11fdf(%rip)     # 0x18040
movq 0x11bb0(%rip), %r13     # 0x17c18
leaq 0x117b1(%rip), %r12     # 0x17820
movb (%r13,%r12), %al
movb %al, 0x11ba6(%rip)      # 0x17c20
movq 0x11b87(%rip), %rbx     # 0x17c08
cmpq %r13, %rbx
jge 0x6104
callq 0x21a0
movq %rax, %r14
leaq 0x1(%rsp), %r15
movq (%r14), %rcx
movsbq (%rbx,%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x60d1
movq 0x11b5f(%rip), %rsi     # 0x17c08
movq %r15, %rdi
movq %r13, %rdx
callq 0x422d
leaq 0x5915(%rip), %rdi      # 0xb9d0
movq %r15, %rsi
movq %rbx, %rdx
callq 0x42a8
movq 0x11b4b(%rip), %rbx     # 0x17c18
xorl %eax, %eax
jmp 0x60f3
incq %rbx
leaq (,%rbp,4), %rcx
addq %rbp, %rcx
leaq (%rax,%rcx,2), %rax
addq $-0x30, %rax
cmpq %rbp, %rax
jge 0x60f3
movb $0x1, 0x11f4d(%rip)     # 0x18040
movq 0x11b1e(%rip), %r13     # 0x17c18
movq %rax, %rbp
cmpq %r13, %rbx
jl 0x6093
jmp 0x6107
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: testForLiteralCollision
BOOL testForLiteralCollision( WORD32 loc )
{
  WORD32  pagelc;
  WORD32  pageno;
  BOOL    result = FALSE;

  pageno  = GET_PAGE (loc);
  pagelc  = loc & 00177;

  if( pageno == 0 )
  {
    if( pagelc >= lit_loc[pageno] && !pz.error )
    {
      errorMessage( &pz_literal_overflow, -1 );
      pz.error = TRUE;
      result = TRUE;
    }
  }
  else
  {
    if( pagelc >= lit_loc[pageno] && !cp.error )
    {
      errorMessage( &literal_overflow, -1 );
      cp.error = TRUE;
      result = TRUE;
    }
  }
  return( result );
}

// Assembly:
pushq %rbx
movl %edi, %eax
shrl $0x7, %eax
movzbl %al, %ecx
andl $0x7f, %edi
testl %ecx, %ecx
je 0x687c
leaq 0xff76(%rip), %rdx      # 0x167d0
xorl %eax, %eax
cmpq (%rdx,%rcx,8), %rdi
jl 0x68b4
cmpq $0x0, 0x10776(%rip)     # 0x16fe0
jne 0x68b4
leaq 0x1076d(%rip), %rbx     # 0x16fe0
leaq 0x51e6(%rip), %rdi      # 0xba60
jmp 0x689f
xorl %eax, %eax
cmpq 0xff4b(%rip), %rdi      # 0x167d0
jl 0x68b4
cmpq $0x0, 0x10b59(%rip)     # 0x173e8
jne 0x68b4
leaq 0x10b50(%rip), %rbx     # 0x173e8
leaq 0x51d1(%rip), %rdi      # 0xba70
movq $-0x1, %rsi
callq 0x5bd7
movq $0x1, (%rbx)
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: topOfForm
void topOfForm( char *title, char *sub_title )
{
  char temp[30]; // [10] to [30] donorth 2020-03-18

  if (!listfile) return;
  list_pageno++;
  strcpy( temp, s_page );
  sprintf( temp, "%s %d", s_page, list_pageno );

  /* Output a top of form if not the first page of the listing.               */
  if( list_pageno > 1 )
  {
    fprintf( listfile, "\f" );
  }
  fprintf( listfile, "\n      %-63s %10s\n", title, temp );

  /* Reset the current page line counter.                                     */
  page_lineno = 1;
  if( sub_title != NULL )
  {
    fprintf( listfile, "%80s\n", sub_title );
    page_lineno++;
  }
  else
  {
    fprintf( listfile, "\n" );
    page_lineno++;
  }
  fprintf( listfile, "\n" );
  page_lineno++;
}

// Assembly:
cmpq $0x0, 0xf59b(%rip)      # 0x15e80
je 0x69cd
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10efd(%rip), %ebp     # 0x17800
incl %ebp
movl %ebp, 0x10ef5(%rip)     # 0x17800
leaq 0x5037(%rip), %r15      # 0xb949
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2070
leaq 0x104a(%rip), %rsi      # 0x7971
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2170
cmpl $0x2, 0x10ec3(%rip)     # 0x17800
jl 0x6950
movq 0xf53a(%rip), %rsi      # 0x15e80
movl $0xc, %edi
callq 0x20e0
movq 0xf529(%rip), %rdi      # 0x15e80
leaq 0x1019(%rip), %rsi      # 0x7977
movq %rsp, %rcx
movq %r14, %rdx
xorl %eax, %eax
callq 0x2120
movl $0x1, 0x10e97(%rip)     # 0x1780c
movq 0xf504(%rip), %rax      # 0x15e80
testq %rbx, %rbx
je 0x6997
leaq 0x1002(%rip), %rsi      # 0x798a
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
jmp 0x69a4
movl $0xa, %edi
movq %rax, %rsi
callq 0x20e0
incl 0x10e62(%rip)           # 0x1780c
movq 0xf4cf(%rip), %rsi      # 0x15e80
movl $0xa, %edi
callq 0x20e0
incl 0x10e4b(%rip)           # 0x1780c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: printErrorMessages
void printErrorMessages()
{
  WORD32  ix;
  WORD32  iy;

  if( listfile != NULL )
  {
    /* If any errors, display them now.                                       */
    for( iy = 0; iy < save_error_count; iy++ )
    {
      printPageBreak();
      fprintf( listfile, "%-18.18s", error_list[iy].mesg );
      if( error_list[iy].col >= 0 )
      {
        for( ix = 0; ix < error_list[iy].col; ix++ )
        {
          if( line[ix] == '\t' )
          {
            putc( '\t', listfile );
          }
          else
          {
            putc( ' ', listfile );
          }
        }
        fputs( "^", listfile );
        list_lineno++;
        page_lineno++;
      }
      fputs( "\n", listfile );
    }
  }
  save_error_count = 0;
}

// Assembly:
cmpq $0x0, 0xf43d(%rip)      # 0x15e80
je 0x6b28
cmpl $0x0, 0x72dc(%rip)      # 0xdd2c
jle 0x6b28
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x119e8(%rip), %r12     # 0x18450
leaq 0x10db1(%rip), %r13     # 0x17820
leaq 0xdbf(%rip), %r15       # 0x7835
xorl %r14d, %r14d
callq 0x69ce
movq 0xf3fb(%rip), %rdi      # 0x15e80
movq %r14, %rbp
shlq $0x4, %rbp
movq (%rbp,%r12), %rdx
leaq 0xe0c(%rip), %rsi       # 0x78a4
xorl %eax, %eax
callq 0x2120
cmpq $0x0, 0x8(%rbp,%r12)
js 0x6af8
addq %r12, %rbp
cmpq $0x0, 0x8(%rbp)
jle 0x6ad9
xorl %ebx, %ebx
cmpb $0x9, (%rbx,%r13)
movl $0x9, %edi
je 0x6ac4
movl $0x20, %edi
movq 0xf3b5(%rip), %rsi      # 0x15e80
callq 0x2100
incq %rbx
cmpq 0x8(%rbp), %rbx
jl 0x6ab3
movq 0xf3a0(%rip), %rsi      # 0x15e80
leaq 0xdc6(%rip), %rdi       # 0x78ad
callq 0x20c0
incl 0x10d12(%rip)           # 0x17804
incl 0x10d14(%rip)           # 0x1780c
movq 0xf381(%rip), %rsi      # 0x15e80
movq %r15, %rdi
callq 0x20c0
incq %r14
movslq 0x721b(%rip), %rax      # 0xdd2c
cmpq %rax, %r14
jl 0x6a79
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x0, 0x71fa(%rip)      # 0xdd2c
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchLocObject
void punchLocObject( WORD32 loc, WORD32 val )
{
  if( rim_mode )
  {
    punchOrigin( loc );
  }
  punchObject(( val >> 6 ) & 0077 );
  punchObject( val & 0077 );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, 0x5153(%rip)      # 0xbc94
je 0x6b48
callq 0x3f07
movq 0xf2a1(%rip), %rsi      # 0x15df0
testq %rsi, %rsi
je 0x6b6e
movl %ebx, %r14d
shrl $0x6, %r14d
andl $0x3f, %r14d
movl %r14d, %edi
callq 0x20e0
addq %r14, 0xf1f2(%rip)      # 0x15d60
movb $0x1, 0x511b(%rip)      # 0xbc90
movq 0xf274(%rip), %rsi      # 0x15df0
testq %rsi, %rsi
je 0x6b92
andl $0x3f, %ebx
movl %ebx, %edi
callq 0x20e0
addq %rbx, 0xf1ce(%rip)      # 0x15d60
movb $0x1, 0x50f7(%rip)      # 0xbc90
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchObject
void punchObject( WORD32 val )
{
  val &= 0377;
  if( objectfile != NULL )
  {
    fputc( val, objectfile );
    checksum += val;
  }
  binary_data_output = TRUE;
}

// Assembly:
movq 0xf248(%rip), %rsi      # 0x15df0
testq %rsi, %rsi
je 0x6bc1
pushq %rbx
movzbl %dil, %ebx
movl %ebx, %edi
callq 0x20e0
addq %rbx, 0xf1a0(%rip)      # 0x15d60
popq %rbx
movb $0x1, 0x50c8(%rip)      # 0xbc90
retq
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: conditionFalse
void conditionFalse()
{
  int     level;

  if( line[lexstart] == '<' )
  {
    /* Invariant: line[cc] is the next unexamined character.                  */
    level = 1;
    while( level > 0 )
    {
      if( is_end( line[cc] ) || ( line[cc] == '/' ))
      {
        readLine();
      }
      else
      {
        switch( line[cc] )
        {
        case '>':
          level--;
          cc++;
          break;

        case '<':
          level++;
          cc++;
          break;

        case '$':
          level = 0;
          cc++;
          break;

        default:
          cc++;
          break;
        } /* end switch                                                       */
      } /* end if                                                             */
    } /* end while                                                            */
    nextLexeme();
  }
  else
  {
    errorMessage( &lt_expected, lexstart );
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x10d33(%rip), %rsi     # 0x17c08
leaq 0x10944(%rip), %rbx     # 0x17820
cmpb $0x3c, (%rsi,%rbx)
jne 0x6f48
movl $0x1, %ebp
movq 0x10d42(%rip), %rax     # 0x17c30
movzbl (%rax,%rbx), %ecx
cmpl $0x2e, %ecx
jg 0x6f13
testl %ecx, %ecx
je 0x6f22
cmpl $0xa, %ecx
je 0x6f22
cmpl $0x24, %ecx
jne 0x6f2f
incq %rax
movq %rax, 0x10d21(%rip)     # 0x17c30
xorl %ebp, %ebp
jmp 0x6f39
cmpl $0x3e, %ecx
je 0x6f29
cmpl $0x3c, %ecx
je 0x6f2d
cmpl $0x2f, %ecx
jne 0x6f2f
callq 0x37ea
jmp 0x6f39
decl %ebp
jmp 0x6f2f
incl %ebp
incq %rax
movq %rax, 0x10cf7(%rip)     # 0x17c30
testl %ebp, %ebp
jg 0x6ee7
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3ab5
leaq 0x4bd1(%rip), %rdi      # 0xbb20
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5bd7
// File: /workspace/github_c_makefile_star2_O1/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: saveError
void saveError( char *mesg, WORD32 col )
{
  if( save_error_count < DIM( error_list ))
  {
    error_list[save_error_count].mesg = mesg;
    error_list[save_error_count].col = col;
    save_error_count++;
  }
  error_in_line = TRUE;

  if( listed )
  {
    printErrorMessages();
  }
}

// Assembly:
movl 0x6da7(%rip), %eax      # 0xdd2c
cmpq $0x13, %rax
ja 0x6faa
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x114b7(%rip), %rdx     # 0x18450
movq %rdi, (%rcx,%rdx)
movq %rsi, 0x8(%rcx,%rdx)
incl %eax
movl %eax, 0x6d82(%rip)      # 0xdd2c
movb $0x1, 0x10c5f(%rip)     # 0x17c10
cmpq $0x0, 0x10837(%rip)     # 0x177f0
jne 0x6a3b
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(unsigned char *c,unsigned long long *clen,
			const unsigned char *m, unsigned long long mlen,
			const unsigned char *ad,unsigned long long adlen,
			const unsigned char *nsec,
			const unsigned char *npub,
			const unsigned char *k)
{
  struct poet_ctx ctx;
  unsigned char *header = malloc((size_t) (adlen+CRYPTO_NPUBBYTES));
  unsigned char *tag = c+mlen;

  *clen=mlen+CRYPTO_NPUBBYTES;
  keysetup(&ctx, k);
  memcpy(header,ad,adlen);
  memcpy(header+adlen,npub,CRYPTO_NPUBBYTES);
  process_header(&ctx, header,adlen+CRYPTO_NPUBBYTES);
  encrypt_final(&ctx, m, mlen, c, tag);


  return 0;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp            # imm = 0x478
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movq %rdx, 0x18(%rsp)
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x10(%r9), %r15
movq %r15, %rdi
callq 0x1060
movq %rax, %r13
leaq (%r14,%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rbx), %rax
movq %rax, (%rbp)
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq 0x4c0(%rsp), %rsi
callq 0x1110
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x1100
movq 0x4b8(%rsp), %rax
vmovups (%rax), %xmm0
vmovups %xmm0, (%r13,%r12)
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10d0
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq 0x10(%rsp), %r8
callq 0x1070
xorl %eax, %eax
addq $0x478, %rsp            # imm = 0x478
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/aes128poetv1aes4/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(unsigned char *m,unsigned long long *mlen,
			unsigned char *nsec,
			const unsigned char *c,unsigned long long clen,
			const unsigned char *ad,unsigned long long adlen,
			const unsigned char *npub,
			const unsigned char *k)
{
  struct poet_ctx ctx;
  unsigned char *header =  malloc((size_t) (adlen+CRYPTO_NPUBBYTES));
  unsigned char tag[CRYPTO_NPUBBYTES];
  int result;

  if(clen < CRYPTO_NPUBBYTES) return -1;
  *mlen = clen - CRYPTO_NPUBBYTES;

  keysetup(&ctx, k);
  memcpy(tag,c+(clen-CRYPTO_NPUBBYTES), CRYPTO_NPUBBYTES);

  memcpy(header,ad, adlen);
  memcpy(header+adlen, npub, CRYPTO_NPUBBYTES);
  process_header(&ctx, header, adlen+CRYPTO_NPUBBYTES);

  result = decrypt_final(&ctx, c, *mlen, tag,m);

  if (result) return -1;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp            # imm = 0x478
movq %r9, (%rsp)
movq %r8, %r13
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq 0x4b0(%rsp), %rbp
leaq 0x10(%rbp), %r12
movq %r12, %rdi
callq 0x1060
movq %rax, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x10, %r13
jb 0x3932
movq 0x4c0(%rsp), %rsi
leaq -0x10(%r13), %rax
movq %rax, (%r15)
leaq 0x20(%rsp), %rdi
callq 0x1110
vmovups -0x10(%r14,%r13), %xmm0
leaq 0x10(%rsp), %r13
vmovaps %xmm0, (%r13)
movq %rbx, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x1100
movq 0x4b8(%rsp), %rax
vmovups (%rax), %xmm0
vmovups %xmm0, (%rbx,%rbp)
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10d0
movq (%r15), %rdx
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rcx
movq 0x8(%rsp), %r8
callq 0x1080
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0x478, %rsp            # imm = 0x478
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/aes128poetv1aes4/ref/poet.c
// Function: keysetup
void keysetup(struct poet_ctx *ctx, const uint8_t key[KEYLEN_BITS]){

  uint8_t ctr[BLOCKLEN];
  AES_KEY aes_enc;

  memset(ctx->tau,0,BLOCKLEN);
  memset(ctr,0, BLOCKLEN);

  /* Generate block cipher key */
  AES_set_encrypt_key(key, KEYLEN_BITS, &aes_enc);
  AES_encrypt(ctr, ctx->k,  &aes_enc);

  AES_set_encrypt_key(ctx->k, KEYLEN_BITS, &(ctx->aes_enc));
  AES_set_decrypt_key(ctx->k, KEYLEN_BITS, &(ctx->aes_dec));

  /* Generate header key */
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->l,  &aes_enc);

  /* Generate almost XOR universal hash function keys */
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->lt,  &aes_enc);
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->lb,  &aes_enc);
  AES_set_encrypt_key(ctx->lt, KEYLEN_BITS, &(ctx->aes_lt));
  AES_set_encrypt_key(ctx->lb, KEYLEN_BITS, &(ctx->aes_lb));

  /* Generate tag masking keys */
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->tm,  &aes_enc);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x440(%rdi)
movq %rsp, %r14
vmovaps %xmm0, (%r14)
leaq 0x1c(%rsp), %r15
movq %rsi, %rdi
movl $0x80, %esi
movq %r15, %rdx
callq 0x10c0
leaq 0x3d0(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1050
movq %r12, %rdi
movl $0x80, %esi
movq %rbx, %rdx
callq 0x10c0
leaq 0xf4(%rbx), %rdx
movq %r12, %rdi
movl $0x80, %esi
callq 0x1040
incb 0xf(%r14)
leaq 0x3f0(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1050
incb 0xf(%r14)
leaq 0x400(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1050
incb 0xf(%r14)
leaq 0x410(%rbx), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1050
leaq 0x1e8(%rbx), %rdx
movq %r12, %rdi
movl $0x80, %esi
callq 0x10c0
leaq 0x2dc(%rbx), %rdx
movq %r13, %rdi
movl $0x80, %esi
callq 0x10c0
incb 0xf(%r14)
addq $0x3e0, %rbx            # imm = 0x3E0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1050
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/poet.c
// Function: process_header
void process_header(struct poet_ctx *ctx, const uint8_t  *header,
		    uint64_t header_len)
{
  block mask;
  block factor;
  block in;
  block out;
  block product;
  uint64_t offset=0;

  ctx->mlen=0;
  memset(factor,0,BLOCKLEN);
  memset(product,0,BLOCKLEN);
  memset(mask,0,BLOCKLEN);
  memset(ctx->tau,0,BLOCKLEN);

  product[0] = 0x80; // since 1000 0000 = 1
  factor[0]  = 0x40; // since 0100 0000 = 2

  while(header_len > BLOCKLEN)
    {
      gf_mul(mask, product, ctx->l);
      xor_block(in,header+offset,mask);
      AES_encrypt(in,out,&(ctx->aes_enc));
      xor_block(ctx->tau,out,ctx->tau);

      offset += BLOCKLEN;
      header_len -= BLOCKLEN;

      gf_mul(product,product,factor);
    }

  /* LASTBLOCK */
  if(header_len < 16)
    {
      factor[0]=0xA0; // 1010 0000 = 5 in Big Endian
      memset(in,0,BLOCKLEN);
      memcpy(in,header+offset,header_len);
      in[header_len]=0x80;
    }
  else
    {
      factor[0]=0xC0; // 1100 0000 = 3 in Big Endian
      memcpy(in,header+offset,BLOCKLEN);
    }

  gf_mul(product,product,factor);
  gf_mul(mask,product,ctx->l);
  xor_block(in,mask,in);

  xor_block(in,in,ctx->tau);
  AES_encrypt(in ,ctx->tau, &(ctx->aes_enc));

  memcpy(ctx->x, ctx->tau, BLOCKLEN);
  memcpy(ctx->y, ctx->tau, BLOCKLEN);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq $0x0, 0x450(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x10(%rsp)
vmovaps %xmm0, 0x20(%rsp)
vmovaps %xmm0, 0x30(%rsp)
movq %rdx, %r14
movq %rsi, %r15
vmovups %xmm0, 0x440(%rdi)
movb $-0x80, 0x20(%rsp)
movb $0x40, 0x10(%rsp)
cmpq $0x11, %rdx
jb 0x3cbb
leaq 0x3f0(%rbx), %r12
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x1030
vmovaps 0x30(%rsp), %xmm0
vxorps (%r15,%r13), %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
callq 0x1050
vmovups 0x440(%rbx), %xmm0
vxorps 0x40(%rsp), %xmm0, %xmm0
vmovups %xmm0, 0x440(%rbx)
addq $0x10, %r13
addq $-0x10, %r14
movq %rbp, %rdi
movq %rbp, %rsi
leaq 0x10(%rsp), %rdx
callq 0x1030
cmpq $0x10, %r14
ja 0x3c54
jmp 0x3cbe
xorl %r13d, %r13d
leaq 0x440(%rbx), %r12
cmpq $0x10, %r14
jne 0x3cdd
movb $-0x40, 0x10(%rsp)
vmovups (%r15,%r13), %xmm0
vmovaps %xmm0, (%rsp)
jmp 0x3d00
movb $-0x60, 0x10(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %rdi
vmovaps %xmm0, (%rdi)
addq %r13, %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x1100
movb $-0x80, (%rsp,%r14)
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1030
leaq 0x3f0(%rbx), %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1030
movq %rsp, %rdi
vmovaps (%rdi), %xmm0
vxorps (%r15), %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
vxorps 0x440(%rbx), %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1050
vmovups (%r12), %xmm0
vmovups %xmm0, 0x420(%rbx)
vmovups (%r12), %xmm0
vmovups %xmm0, 0x430(%rbx)
addq $0x58, %rsp
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/aes128poetv1aes4/ref/poet.c
// Function: encrypt_block
void encrypt_block(struct poet_ctx *ctx, const uint8_t plaintext[16],
		   uint8_t ciphertext[16])
{
  block tmp;
  TOP_HASH;
  xor_block(ctx->x, plaintext,ctx->x);

  AES_encrypt(ctx->x, tmp, &(ctx->aes_enc));

  BOTTOM_HASH;
  xor_block(ciphertext, tmp,ctx->y);

  memcpy(ctx->y, tmp, BLOCKLEN);
  ctx->mlen+=BLOCKLEN_BITS;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x420(%rdi), %r15
leaq 0x1e8(%rdi), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x10f0
movl $0x420, %eax            # imm = 0x420
movb -0x420(%r12,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x430, %rax            # imm = 0x430
jne 0x3db0
movq %rsp, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1050
leaq 0x430(%rbx), %r15
leaq 0x2dc(%rbx), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x10f0
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb (%rsp,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x3def
vmovaps (%rsp), %xmm0
vmovups %xmm0, (%r15)
subq $-0x80, 0x450(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/poet.c
// Function: decrypt_block
void decrypt_block(struct poet_ctx *ctx, const uint8_t ciphertext[16],
		   uint8_t plaintext[16])
{
  block tmp;
  BOTTOM_HASH;
  xor_block(ctx->y, ciphertext,ctx->y);

  AES_decrypt(ctx->y, tmp, &(ctx->aes_dec));

  TOP_HASH;
  xor_block(plaintext, tmp,ctx->x);

  memcpy(ctx->x, tmp, BLOCKLEN);
  ctx->mlen+=BLOCKLEN_BITS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x430(%rdi), %r15
leaq 0x2dc(%rdi), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x10f0
xorl %eax, %eax
movb (%r12,%rax), %cl
xorb %cl, (%r15,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x404f
leaq 0xf4(%rbx), %rdx
movq %rsp, %rsi
movq %r15, %rdi
callq 0x10b0
leaq 0x420(%rbx), %r15
leaq 0x1e8(%rbx), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x10f0
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb (%rsp,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x408d
vmovaps (%rsp), %xmm0
vmovups %xmm0, (%r15)
subq $-0x80, 0x450(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_lock_slow
int skinny_mutex_lock_slow(skinny_mutex_t *skinny)
{
	for (;;) {
		struct common *head = skinny->val;
		if (head) {
			struct fat_mutex *fat;
			int res = fat_mutex_get(skinny, head, &fat);
			if (!res) {
				fat->refcount++;
				res = fat_mutex_lock(skinny, fat);
			}

			if (res >= 0)
				return res;

			/* skinny_mutex value changed under us, try
			   again. */
		}
		else {
			/* Recapitulate skinny_mutex_lock */
			if (cas(&skinny->val, head, (void *)1))
				return 0;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r15d
movq %rsp, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1401
movq %rbx, %rdi
movq %r14, %rdx
callq 0x142c
testl %eax, %eax
jne 0x13f6
movq (%rsp), %rsi
incq 0x10(%rsi)
movq %rbx, %rdi
callq 0x1517
testl %eax, %eax
cmovnsl %eax, %ebp
js 0x1415
xorl %ecx, %ecx
jmp 0x141b
xorl %ecx, %ecx
xorl %eax, %eax
lock
cmpxchgq %r15, (%rbx)
movl %ebp, %eax
movl $0x0, %ebp
jne 0x1417
jmp 0x141b
movl %ebp, %eax
movb $0x1, %cl
movl %eax, %ebp
testb %cl, %cl
jne 0x13cf
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_get
static int fat_mutex_get(skinny_mutex_t *skinny, struct common *head,
			 struct fat_mutex **fatp)
{
	if ((uintptr_t)head <= 1)
		return skinny_mutex_promote(skinny, head, fatp);
	else
		return fat_mutex_peg(skinny, head, fatp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x1, %rsi
ja 0x14e5
movl $0x70, %edi
callq 0x1110
movq %rax, (%r14)
testq %rax, %rax
je 0x1501
movq %rax, %rbx
movw $0x100, (%rax)          # imm = 0x100
movq $0x1, 0x10(%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rax), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x11a0
movl %eax, %ebp
testl %eax, %eax
jne 0x14db
movq %rbx, %r13
addq $0x40, %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x10f0
movl %eax, %ebp
testl %eax, %eax
jne 0x14d3
movq %r14, %rdi
callq 0x11b0
movl %eax, %ebp
testl %eax, %eax
jne 0x14cb
xorl %ebp, %ebp
movq %r15, %rax
lock
cmpxchgq %rbx, (%r12)
je 0x1506
movq %r14, %rdi
callq 0x1100
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r13, %rdi
callq 0x1160
movq %r14, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1030
jmp 0x1506
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1690
movl $0xc, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_lock
static int fat_mutex_lock(skinny_mutex_t *skinny, struct fat_mutex *fat)
{
	if (fat->held) {
		/* The mutex is already held, so we have to wait for
		 * it. */
		fat->waiters++;

		do {
			int res, old_state, old_state2;

			/* skinny_mutex_lock is not a cancellation
			   point, but pthread_cond_wait is, so we need
			   to defer cancellation around it. */
			assert(!pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
						       &old_state));
			res = pthread_cond_wait(&fat->held_cond, &fat->mutex);
			assert(!pthread_setcancelstate(old_state, &old_state2));

			if (res) {
				fat->waiters--;
				return recover(res,
					       fat_mutex_release(skinny, fat));
			}
		} while (fat->held);

		fat->waiters--;
	}

	fat->held = 1;
	return pthread_mutex_unlock(&fat->mutex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, 0x1(%rsi)
je 0x159a
movq %rdi, %r14
incq 0x8(%rbx)
leaq 0x40(%rbx), %r15
leaq 0x18(%rbx), %r12
movl $0x1, %edi
movq %rsp, %rsi
callq 0x1070
testl %eax, %eax
jne 0x15de
movq %r15, %rdi
movq %r12, %rsi
callq 0x1060
movl %eax, %ebp
movl (%rsp), %edi
leaq 0x4(%rsp), %rsi
callq 0x1070
testl %eax, %eax
jne 0x15bf
testl %ebp, %ebp
je 0x158c
decq 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1886
movl %ebp, %edi
movl %eax, %esi
callq 0x1793
movl %eax, %r13d
testl %ebp, %ebp
jne 0x15ad
cmpb $0x0, 0x1(%rbx)
jne 0x153a
decq 0x8(%rbx)
movb $0x1, 0x1(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1100
movl %eax, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ac2(%rip), %rdi      # 0x3088
leaq 0x1a73(%rip), %rsi      # 0x3040
leaq 0x1a7b(%rip), %rcx      # 0x304f
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x10c0
leaq 0x1a1f(%rip), %rdi      # 0x3004
leaq 0x1a54(%rip), %rsi      # 0x3040
leaq 0x1a5c(%rip), %rcx      # 0x304f
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x10c0