LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/System-Glitch[P]ESGILinter-C/src/parsing_functions.c
// Function: function_init
function_t *function_init(char *name, unsigned char is_prototype, char *type, unsigned char type_is_pointer, arraylist_t *params, int line_index) {
	function_t *function = malloc(sizeof(function_t));

	if(function != NULL) {
		function->name                   = name;
		function->is_prototype           = is_prototype;
		function->return_type.name       = type;
		function->return_type.is_pointer = type_is_pointer;
		function->params                 = params;
		function->line                   = line_index;
		function->negate_operator        = 0;
	}

	return function;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
pushq $0x30
popq %rdi
callq 0x2130
testq %rax, %rax
je 0xa4ab
movq %r13, (%rax)
movb %r12b, 0x18(%rax)
movq %r15, 0x8(%rax)
movb %bpl, 0x10(%rax)
movq %r14, 0x20(%rax)
movl %ebx, 0x28(%rax)
andl $0x0, 0x2c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x8(%rsp)
movq %rdi, %r12
testq %rdx, %rdx
je 0xadf9
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0xadf9
cmpq $0x0, 0x18(%rbx)
je 0xadf9
pushq $0x10
popq %rdi
callq 0x2130
movq %rax, %r15
movq (%r14), %rdi
callq 0x794d
movq %rax, (%r15)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %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 0x68b5
xorl %r13d, %r13d
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
cmpq 0x8(%rdi), %r13
jae 0xaeef
movq %r13, %rsi
callq 0x6978
movq %rax, %r15
movq (%rax), %rdi
movl 0x4(%rsp), %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xaf1c
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, %rdi
leaq 0x3a70(%rip), %rsi      # 0xe8b0
callq 0x2110
testl %eax, %eax
jne 0xae65
movq (%r15), %rdi
movl 0x4(%rsp), %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x6ce0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
testq %r14, %r14
je 0xaee7
movq 0x20(%r14), %rdi
cmpq 0x8(%rdi), %r13
jae 0xaee7
movq %r13, %rsi
callq 0x6978
movq %rax, %rbp
movq 0x10(%rsp), %rdi
leaq 0x3a25(%rip), %rsi      # 0xe8b0
callq 0x2110
testl %eax, %eax
je 0xaee7
addq $0x10, %rbp
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x652a
testb %al, %al
jne 0xaee7
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movq (%r15), %rdi
callq 0x794d
movq %rax, %rbp
movq 0x10(%r15), %rdi
callq 0x794d
movsbl 0x18(%r15), %edx
movl 0x20(%r15), %ecx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x5ee4
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x68b5
incq %r13
jmp 0xadfc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
pushq $0x3b
popq %r15
movslq %ebx, %rbx
leaq (%r14,%rbx), %rdi
movl %r15d, %esi
callq 0x7b48
addl %eax, %ebx
cmpl $-0x1, %ebx
je 0xc2c9
movslq %ebx, %rsi
addq %r14, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x7e2e
testb %al, %al
je 0xc2c9
incl %ebx
jmp 0xc29b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/include/hex.h
// Function: hexString8ToUint8
static inline uint8_t hexString8ToUint8(const uint8_t hexString8) {
    if ('0' <= hexString8 && hexString8 <= '9') {
        return hexString8 - '0';
    }
    if ('a' <= hexString8 && hexString8 <= 'f') {
        return hexString8 - 'a' + 0xa;
    }
    if ('A' <= hexString8 && hexString8 <= 'F') {
        return hexString8 - 'A' + 0xa;
    }
    fprintf(stderr, "hexString8ToUint8: unexpected hex string %u (%c)\n", hexString8, hexString8);
    return 0xff;
}

// Assembly:
movl %edi, %ecx
leal -0x30(%rcx), %eax
cmpb $0xa, %al
jb 0xc883
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0xc884
leal -0x57(%rcx), %eax
retq
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0xc88f
leal -0x37(%rcx), %eax
retq
pushq %rax
movq 0xa761(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
leaq 0x8dfc(%rip), %rsi      # 0x1569d
movl %ecx, %edx
xorl %eax, %eax
callq 0x2070
movb $-0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ae8
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
andl $0xfff, %r14d           # imm = 0xFFF
callq 0x3ed2
movq %rax, %rbx
movl (%rax), %eax
testb $0x1, %al
jne 0x2afd
testb $0x2, %al
jne 0x2aef
movq 0xb283(%rip), %rax      # 0xdd20
cmpq $0x2, %rax
jne 0x2ad1
cmpb $0x0, 0x91dc(%rip)      # 0xbc86
je 0x2ad1
movslq 0x14d39(%rip), %rax     # 0x177ec
movq 0x133c6(%rip), %rcx     # 0x15e80
movq 0x18(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x18(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0xb24f(%rip), %rax      # 0xdd20
movq %r14, 0x10(%rbx)
movl %ebp, %ecx
orl $0x80, %ecx
cmpq $0x1, %rax
cmovnel %ebp, %ecx
movl %ecx, (%rbx)
jmp 0x2aef
leaq 0x9159(%rip), %rbx      # 0xbc48
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testw $0x14e, %ax             # imm = 0x14E
je 0x2a92
cmpq %r14, 0x10(%rbx)
je 0x2a92
cmpq $0x2, 0xb20f(%rip)      # 0xdd20
jne 0x2aef
movq %rbx, %rsi
addq $0x4, %rsi
leaq 0x8f1f(%rip), %rdi      # 0xba40
movq %r15, %rdx
callq 0x4043
incq 0x20(%rbx)
jmp 0x2aef
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x12dd3(%rip)     # 0x15de0
je 0x303c
pushq %rbx
xorl %eax, %eax
testq %rdi, %rdi
cmovgq %rdi, %rax
movl $0xf0, %ebx
cmovneq %rax, %rbx
subq $0x1, %rbx
jb 0x303b
movq 0x12db1(%rip), %rsi     # 0x15de0
movl $0x80, %edi
callq 0x20e0
jmp 0x3022
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, 0x142b2(%rip)     # 0x177fc
andl $0x0, 0x142a3(%rip)     # 0x177f4
leaq 0xa7e8(%rip), %r14      # 0xdd40
pushq $0x2e
popq %r15
pushq $0x58
popq %r12
xorl %ebx, %ebx
cmpq 0x127df(%rip), %rbx     # 0x15d48
jg 0x3644
movq %rbx, %rax
shlq $0x35, %rax
je 0x3583
cmpl $0x3c, 0x1427d(%rip)    # 0x177fc
jge 0x358d
jmp 0x35a0
movl $0x3c, 0x1426f(%rip)    # 0x177fc
leaq 0x14abc(%rip), %rdi     # 0x18050
leaq 0x83c5(%rip), %rsi      # 0xb960
callq 0x5fea
xorl %eax, %eax
incl 0x14254(%rip)           # 0x177fc
movl 0x14246(%rip), %edx     # 0x177f4
incl %edx
movl %edx, 0x1423e(%rip)     # 0x177f4
movq 0x128b3(%rip), %rdi     # 0x15e70
cmpl $0x2, %eax
je 0x3631
movl %eax, 0x4(%rsp)
xorl %ebp, %ebp
leaq 0x43bf(%rip), %rsi      # 0x798e
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2120
movq 0x12891(%rip), %rsi     # 0x15e70
cmpl $0x8, %ebp
je 0x361e
pushq $0x20
popq %rdi
callq 0x20e0
xorl %r13d, %r13d
cmpl $0x8, %r13d
je 0x3617
leaq (%rbx,%r13), %rax
cmpb $0x0, (%r14,%rax)
movl %r15d, %edi
je 0x3606
movl %r12d, %edi
movq 0x12863(%rip), %rsi     # 0x15e70
callq 0x20e0
incq %r13
jmp 0x35ef
incl %ebp
addq %r13, %rbx
jmp 0x35d8
pushq $0xa
popq %rdi
callq 0x20e0
movl 0x4(%rsp), %eax
incl %eax
jmp 0x35a2
leaq 0x4360(%rip), %rsi      # 0x7998
xorl %eax, %eax
callq 0x2120
jmp 0x3562
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq 0x1429e(%rip), %rax     # 0x17bf8
movq %rax, 0x142b7(%rip)     # 0x17c18
movq 0x142a0(%rip), %rax     # 0x17c08
movq %rax, 0x16ca9(%rip)     # 0x1a618
movq 0x142aa(%rip), %rbx     # 0x17c20
leaq 0x13e93(%rip), %r14     # 0x17810
movabsq $0x4000000100001200, %rax # imm = 0x4000000100001200
movzbl (%rbx,%r14), %r15d
cmpq $0x3e, %r15
ja 0x39a4
btq %r15, %rax
jae 0x39a4
incq %rbx
movq %rbx, 0x1427e(%rip)     # 0x17c20
jmp 0x3987
movsbq %r15b, %r12
movq %rbx, 0x14249(%rip)     # 0x17bf8
callq 0x2190
movq (%rax), %rax
movzwl (%rax,%r12,2), %ecx
testb $0x8, %cl
jne 0x3a01
testb %r15b, %r15b
je 0x3a2c
movzbl %r12b, %eax
cmpl $0xa, %eax
je 0x3a2c
cmpl $0x2f, %eax
je 0x3a2c
cmpl $0x22, %eax
jne 0x3a1c
leaq 0x2(%rbx), %rax
cmpq 0x14644(%rip), %rax     # 0x18028
jl 0x3a22
leaq 0x80f3(%rip), %rdi      # 0xbae0
movq %rbx, %rsi
callq 0x565f
movq 0x14224(%rip), %rax     # 0x17c20
incq %rax
jmp 0x3a22
testb $0x8, %cl
je 0x3a2c
movsbq 0x1(%rbx,%r14), %rcx
incq %rbx
movq %rbx, 0x1420a(%rip)     # 0x17c20
movzwl (%rax,%rcx,2), %ecx
jmp 0x3a01
incq %rbx
movq %rbx, %rax
movq %rax, 0x141f7(%rip)     # 0x17c20
movq %rax, %rbx
movq %rbx, 0x141d5(%rip)     # 0x17c08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12559(%rip), %rsi     # 0x15fa0
decq %rsi
leaq 0x1357f(%rip), %rdi     # 0x16fd0
callq 0x3c51
movq 0x1254b(%rip), %rsi     # 0x15fa8
leaq 0x13974(%rip), %rdi     # 0x173d8
callq 0x3c51
cmpb $0x0, 0x14190(%rip)     # 0x17c00
je 0x3a78
popq %rax
jmp 0x5fc3
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13
andq $0xf80, %r13            # imm = 0xF80
sete %al
leaq 0x13768(%rip), %rcx     # 0x173d8
cmpq %rcx, %rdi
setne %cl
testb %al, %cl
jne 0x3d21
shrl $0x7, %esi
movzbl %sil, %r15d
leal (,%r15,8), %eax
leaq 0x12b2c(%rip), %r12     # 0x167c0
movq (%rax,%r12), %r14
leaq 0x12321(%rip), %rcx     # 0x15fc0
cmpq (%rax,%rcx), %r14
jge 0x3d21
movq %rdi, %rbx
cmpb $0x0, 0x7fd5(%rip)      # 0xbc84
jne 0x3cc0
orq %r13, %r14
movq %r14, %rdi
callq 0x3d30
movq (%r12,%r15,8), %r14
pushq $0x3
popq %rbp
leaq 0x122f6(%rip), %rax     # 0x15fc0
cmpq (%rax,%r15,8), %r14
jge 0x3d03
leaq (%r14,%r13), %r12
movq 0x122cd(%rip), %rsi     # 0x15fa8
orq %r12, %rsi
movq 0x8(%rbx,%r14,8), %rdx
leaq 0x13b26(%rip), %rdi     # 0x17810
movl %ebp, %ecx
callq 0x3d4f
movq 0x8(%rbx,%r14,8), %rsi
movq %r12, %rdi
callq 0x6235
incq %r14
jmp 0x3cc3
andq $0x0, (%rbx)
shll $0x3, %r15d
leaq 0x12aae(%rip), %rax     # 0x167c0
movq (%r15,%rax), %rax
leaq 0x122a3(%rip), %rcx     # 0x15fc0
movq %rax, (%r15,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x1380b(%rip), %r13     # 0x17810
leaq (%r15,%r12), %rax
cmpq %r14, %rax
jge 0x4030
cmpq $0x6, %r12
jae 0x4030
movsbl (%r13,%rax), %edi
callq 0x2080
movb %al, (%rbx,%r12)
incq %r12
jmp 0x4005
movb $0x0, (%rbx,%r12)
incq %r12
cmpq $0x6, %r12
jbe 0x4028
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x9cd5(%rip)      # 0xdd20
jne 0x40db
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x37f6(%rip), %r15      # 0x7862
cmovneq %rsi, %r15
incl 0x9ca2(%rip)            # 0xdd18
movl 0x13770(%rip), %edx     # 0x177ec
leaq 0x1(%rbx), %rcx
leaq 0x3935(%rip), %rsi      # 0x79bc
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x2160
movq 0x9c73(%rip), %rdi      # 0xdd10
movq 0x8(%r14), %r8
movl 0x11ef9(%rip), %eax     # 0x15fa0
movl %eax, (%rsp)
leaq 0x3914(%rip), %rsi      # 0x79c5
leaq 0x11e68(%rip), %rdx     # 0x15f20
movq %r12, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x65fa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movb $0x1, 0x13b1e(%rip)     # 0x17c00
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x138c9(%rip), %rsi     # 0x17bf8
movq 0x138d2(%rip), %rdx     # 0x17c08
leaq 0x9(%rsp), %rbx
movq %rbx, %rdi
callq 0x3fe9
movq %rbx, %rdi
callq 0x3ed2
movq 0x20(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
cmpb $0x0, 0x7928(%rip)      # 0xbc86
je 0x4385
cmpq $0x2, 0x99b8(%rip)      # 0xdd20
jne 0x4385
movslq 0x1347b(%rip), %rdx     # 0x177ec
movq 0x18(%rax), %rsi
shlq $0x3, %rsi
addq 0x11b00(%rip), %rsi     # 0x15e80
movq %rdx, 0x8(%rsi,%rcx,8)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10d0e(%rip), %ecx     # 0x15fa8
shrl $0x4, %ecx
andl $0x7f8, %ecx            # imm = 0x7F8
leaq 0x11516(%rip), %rax     # 0x167c0
movq (%rcx,%rax), %rax
leaq 0x10d0b(%rip), %rdx     # 0x15fc0
movq (%rcx,%rdx), %rcx
leaq 0x12118(%rip), %rdx     # 0x173d8
cmpq %rcx, %rax
jge 0x52d6
leaq 0x1(%rax), %rsi
cmpq %rdi, 0x8(%rdx,%rax,8)
movq %rsi, %rax
jne 0x52c0
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x86b9(%rip)      # 0xdd20
jne 0x56da
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incl 0x869a(%rip)            # 0xdd18
movl 0x12168(%rip), %edx     # 0x177ec
leaq 0x1(%rsi), %rcx
leaq 0x232d(%rip), %rsi      # 0x79bc
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2160
movq 0x866d(%rip), %rdi      # 0xdd10
movq 0x8(%r14), %r8
movl 0x108f2(%rip), %r9d     # 0x15fa0
leaq 0x2339(%rip), %rsi      # 0x79ee
leaq 0x10864(%rip), %rdx     # 0x15f20
movq %r15, %rcx
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x65fa
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x1251f(%rip)     # 0x17c00
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12537(%rip), %rax     # 0x17c20
leaq 0x12120(%rip), %rcx     # 0x17810
movzbl (%rax,%rcx), %edx
testl %edx, %edx
je 0x5709
cmpl $0xa, %edx
je 0x5709
incq %rax
movq %rax, 0x12519(%rip)     # 0x17c20
jmp 0x56f0
movq %rax, 0x124e8(%rip)     # 0x17bf8
movq %rax, 0x124f1(%rip)     # 0x17c08
movq %rax, 0x124fa(%rip)     # 0x17c18
retq
// File: /workspace/github_c_makefile_star2_O2/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: inputDubl
void inputDubl()
{
  WORD32 dublvalue;
  BOOL   scanning_line;

  scanning_line = TRUE;
  do
  {
    while( scanning_line )
    {
      if( is_end( line[lexstart] ))
      {
        scanning_line = FALSE;
      }
      else
      {
        switch( line[lexstart] )
        {
        case '/':
          scanning_line = FALSE;
          break;

        case ';':
          nextLexeme();
          break;

        case '+':
          delimiter = line[lexterm];
          nextLexBlank();
        case '-':
        default:
          if( is_digit( line[lexstart] ) || line[lexstart] == '-' )
          {
            dublvalue = getDublExprs();
            punchOutObject( clc, (WORD32)(( dublvalue >> 12 ) & 07777 ));
            incrementClc();
            punchOutObject( clc, (WORD32)( dublvalue & 07777 ));
            incrementClc();
          }
          else
          {
            return;             /* Non-numeric input, back to assembly.       */
          }
          break;
        } /* end switch                                                       */
      } /* end if                                                             */

      if( error_in_line )
      {
        return;                 /* Error occurred, exit DUBL input mode.      */
      }
    } /* end while( scanning_line )                                           */
    readLine();
    nextLexeme();
    scanning_line = TRUE;
  }
  while( TRUE );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %al
leaq 0x120e4(%rip), %r14     # 0x17810
testb %al, %al
jne 0x573e
callq 0x3653
callq 0x394b
movb $0x1, %al
jmp 0x572c
movq 0x124b3(%rip), %rax     # 0x17bf8
movzbl (%rax,%r14), %ebx
xorl %eax, %eax
testl %ebx, %ebx
je 0x57f9
cmpl $0xa, %ebx
je 0x57f9
movsbl %bl, %eax
addl $-0x2b, %eax
je 0x577c
rorl %eax
cmpl $0x2, %eax
je 0x5778
cmpl $0x8, %eax
jne 0x579d
callq 0x394b
jmp 0x57f7
xorl %eax, %eax
jmp 0x57f9
movq 0x12485(%rip), %rax     # 0x17c08
movb (%rax,%r14), %al
movb %al, 0x12483(%rip)      # 0x17c10
callq 0x4164
movq 0x1245f(%rip), %rax     # 0x17bf8
movb (%rax,%r14), %bl
callq 0x2190
cmpb $0x2d, %bl
je 0x57b9
movq (%rax), %rax
movsbq %bl, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
je 0x5806
callq 0x580e
movq %rax, %rbx
movq 0x107d8(%rip), %rdi     # 0x15fa0
movl %ebx, %esi
shrl $0xc, %esi
andl $0xfff, %esi            # imm = 0xFFF
callq 0x5226
callq 0x525e
movq 0x107bc(%rip), %rdi     # 0x15fa0
andl $0xfff, %ebx            # imm = 0xFFF
movq %rbx, %rsi
callq 0x5226
callq 0x525e
movb $0x1, %al
cmpb $0x0, 0x12400(%rip)     # 0x17c00
je 0x572c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movb $0x0, 0x12685(%rip)     # 0x18030
movq 0x12256(%rip), %r13     # 0x17c08
leaq 0x11e57(%rip), %r12     # 0x17810
movb (%r13,%r12), %al
movb %al, 0x1224c(%rip)      # 0x17c10
movq 0x1222d(%rip), %r14     # 0x17bf8
leaq 0x5fee(%rip), %rbx      # 0xb9c0
cmpq %r13, %r14
jge 0x5a24
callq 0x2190
movq (%rax), %rcx
movsbq (%r14,%r12), %rax
testb $0x8, 0x1(%rcx,%rax,2)
je 0x5a0a
imulq $0xa, %r15, %rcx
addq %rcx, %rax
addq $-0x30, %rax
cmpq %r15, %rax
jge 0x5a02
movb $0x1, 0x1262e(%rip)     # 0x18030
incq %r14
movq %rax, %r15
jmp 0x59d2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4122
movq 0x121ec(%rip), %r13     # 0x17c08
xorl %r15d, %r15d
movq %r13, %r14
jmp 0x59d2
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5f8d
leaq 0x10855(%rip), %rdx     # 0x167c0
xorl %eax, %eax
cmpq (%rdx,%rcx,8), %rdi
jl 0x5fc1
cmpq $0x0, 0x11055(%rip)     # 0x16fd0
jne 0x5fc1
leaq 0x1104c(%rip), %rbx     # 0x16fd0
leaq 0x5ac5(%rip), %rdi      # 0xba50
jmp 0x5fb0
xorl %eax, %eax
cmpq 0x1082a(%rip), %rdi     # 0x167c0
jl 0x5fc1
cmpq $0x0, 0x11438(%rip)     # 0x173d8
jne 0x5fc1
leaq 0x1142f(%rip), %rbx     # 0x173d8
leaq 0x5ab0(%rip), %rdi      # 0xba60
pushq $-0x1
popq %rsi
callq 0x565f
movq $0x1, (%rbx)
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xfe7e(%rip)      # 0x15e70
je 0x60d4
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x117e0(%rip), %ebp     # 0x177f0
incl %ebp
movl %ebp, 0x117d8(%rip)     # 0x177f0
leaq 0x591a(%rip), %r15      # 0xb939
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2070
leaq 0x1969(%rip), %rsi      # 0x799d
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2160
cmpl $0x2, 0x117a6(%rip)     # 0x177f0
jl 0x605b
movq 0xfe1d(%rip), %rsi      # 0x15e70
pushq $0xc
popq %rdi
callq 0x20e0
movq 0xfe0e(%rip), %rdi      # 0x15e70
leaq 0x193a(%rip), %rsi      # 0x79a3
movq %rsp, %rcx
movq %r14, %rdx
xorl %eax, %eax
callq 0x2120
movl $0x1, 0x1177c(%rip)     # 0x177fc
movq 0xfde9(%rip), %rax      # 0x15e70
testq %rbx, %rbx
je 0x60a2
leaq 0x1923(%rip), %rsi      # 0x79b6
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
jmp 0x60ad
pushq $0xa
popq %rdi
movq %rax, %rsi
callq 0x20e0
incl 0x11749(%rip)           # 0x177fc
movq 0xfdb6(%rip), %rsi      # 0x15e70
pushq $0xa
popq %rdi
callq 0x20e0
incl 0x11734(%rip)           # 0x177fc
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xfd26(%rip)      # 0x15e70
je 0x622d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x122de(%rip), %r12     # 0x18440
leaq 0x116a7(%rip), %r13     # 0x17810
pushq $0x9
popq %rbp
pushq $0x20
popq %r14
xorl %r15d, %r15d
movslq 0x7ba2(%rip), %rax      # 0xdd1c
cmpq %rax, %r15
jge 0x621f
callq 0x60d5
movq 0xfce1(%rip), %rdi      # 0x15e70
movq %r15, %rbx
shlq $0x4, %rbx
movq (%rbx,%r12), %rdx
leaq 0x172f(%rip), %rsi      # 0x78d0
xorl %eax, %eax
callq 0x2120
movq 0x8(%rbx,%r12), %rax
testq %rax, %rax
js 0x6204
addq %r12, %rbx
xorl %r12d, %r12d
cmpq %rax, %r12
jge 0x61de
cmpb $0x9, (%r12,%r13)
movl %ebp, %edi
je 0x61c9
movl %r14d, %edi
movq 0xfca0(%rip), %rsi      # 0x15e70
callq 0x2100
incq %r12
movq 0x8(%rbx), %rax
jmp 0x61b8
movq 0xfc8b(%rip), %rsi      # 0x15e70
leaq 0x16ed(%rip), %rdi      # 0x78d9
callq 0x20c0
incl 0x115fd(%rip)           # 0x177f4
incl 0x115ff(%rip)           # 0x177fc
leaq 0x1223c(%rip), %r12     # 0x18440
movq 0xfc65(%rip), %rsi      # 0x15e70
leaq 0x164f(%rip), %rdi      # 0x7861
callq 0x20c0
incq %r15
jmp 0x6173
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
andl $0x0, 0x7ae8(%rip)      # 0xdd1c
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
cmpb $0x0, 0x5a44(%rip)      # 0xbc84
je 0x6247
callq 0x3d30
movl %ebx, %edi
shrl $0x6, %edi
andl $0x3f, %edi
callq 0x6260
andl $0x3f, %ebx
movq %rbx, %rdi
popq %rbx
jmp 0x6260
// File: /workspace/github_c_makefile_star2_O2/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 0xfb79(%rip), %rsi      # 0x15de0
testq %rsi, %rsi
je 0x6280
pushq %rbx
movzbl %dil, %ebx
movl %ebx, %edi
callq 0x20e0
addq %rbx, 0xfad1(%rip)      # 0x15d50
popq %rbx
movb $0x1, 0x59f9(%rip)      # 0xbc80
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x116a5(%rip), %rsi     # 0x17bf8
leaq 0x112b6(%rip), %rbx     # 0x17810
cmpb $0x3c, (%rsi,%rbx)
jne 0x65c3
pushq $0x1
popq %rbp
testl %ebp, %ebp
jle 0x65b8
movq 0x116b2(%rip), %rax     # 0x17c20
movzbl (%rax,%rbx), %ecx
testl %ecx, %ecx
je 0x659b
cmpl $0xa, %ecx
je 0x659b
cmpl $0x2f, %ecx
je 0x659b
cmpl $0x24, %ecx
je 0x65a2
cmpl $0x3c, %ecx
je 0x65b4
cmpl $0x3e, %ecx
je 0x65b0
incq %rax
movq %rax, 0x11687(%rip)     # 0x17c20
jmp 0x6563
callq 0x3653
jmp 0x6563
incq %rax
movq %rax, 0x11674(%rip)     # 0x17c20
xorl %ebp, %ebp
jmp 0x6563
decl %ebp
jmp 0x658f
incl %ebp
jmp 0x658f
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x394b
leaq 0x5546(%rip), %rdi      # 0xbb10
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x565f
// File: /workspace/github_c_makefile_star2_O2/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 0x771c(%rip), %eax      # 0xdd1c
cmpq $0x13, %rax
ja 0x6625
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x11e2c(%rip), %rdx     # 0x18440
movq %rdi, (%rcx,%rdx)
movq %rsi, 0x8(%rcx,%rdx)
incl %eax
movl %eax, 0x76f7(%rip)      # 0xdd1c
movb $0x1, 0x115d4(%rip)     # 0x17c00
cmpq $0x0, 0x111ac(%rip)     # 0x177e0
jne 0x6142
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x10, %r13
jae 0x3897
pushq $-0x1
popq %rax
jmp 0x3916
movq %rax, %rbx
movq 0x4c0(%rsp), %rsi
leaq -0x10(%r13), %rax
movq %rax, (%r15)
leaq 0x20(%rsp), %rdi
callq 0x1120
vmovups -0x10(%r14,%r13), %xmm0
leaq 0x10(%rsp), %r13
vmovaps %xmm0, (%r13)
movq %rbx, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x1110
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_O2/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/gf_mul.h
// Function: gf_mul
void gf_mul(unsigned char *a, const unsigned char *x,
	    const unsigned char *y)
{
  int i;
  int j;
  unsigned int xlen = 16;
  unsigned char abits[128];
  unsigned char ybits[128];
  unsigned char prodbits[256];
  memcpy(a,x,xlen);
  for (i = 0;i < 128;++i) abits[i] = (a[i / 8] >> (7 - (i % 8))) & 1;
  for (i = 0;i < 128;++i) ybits[i] = (y[i / 8] >> (7 - (i % 8))) & 1;
  for (i = 0;i < 256;++i) prodbits[i] = 0;
  for (i = 0;i < 128;++i)
    for (j = 0;j < 128;++j)
      prodbits[i + j] ^= abits[i] & ybits[j];
  for (i = 127;i >= 0;--i) {
    prodbits[i] ^= prodbits[i + 128];
    prodbits[i + 1] ^= prodbits[i + 128];
    prodbits[i + 2] ^= prodbits[i + 128];
    prodbits[i + 7] ^= prodbits[i + 128];
    prodbits[i + 128] ^= prodbits[i + 128];
  }
  for (i = 0;i < 16;++i) a[i] = 0;
  for (i = 0;i < 128;++i) a[i / 8] |= (prodbits[i] << (7 - (i % 8)));
}

// Assembly:
subq $0x188, %rsp            # imm = 0x188
vmovups (%rsi), %xmm0
vmovups %xmm0, (%rdi)
xorl %eax, %eax
cmpq $0x80, %rax
je 0x3966
movl %eax, %ecx
shrl $0x3, %ecx
movl %eax, %esi
notb %sil
movzbl (%rdi,%rcx), %ecx
movzbl %sil, %esi
andl $0x7, %esi
btl %esi, %ecx
setb 0x100(%rsp,%rax)
incq %rax
jmp 0x3939
xorl %eax, %eax
cmpq $0x80, %rax
je 0x3995
movl %eax, %ecx
shrl $0x3, %ecx
movl %eax, %esi
notb %sil
movzbl (%rdx,%rcx), %ecx
movzbl %sil, %esi
andl $0x7, %esi
btl %esi, %ecx
setb 0x80(%rsp,%rax)
incq %rax
jmp 0x3968
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x39a9
movb $0x0, -0x80(%rsp,%rax)
incq %rax
jmp 0x3997
leaq -0x80(%rsp), %rax
xorl %ecx, %ecx
cmpq $0x80, %rcx
je 0x39e7
movb 0x100(%rsp,%rcx), %dl
xorl %esi, %esi
cmpq $0x80, %rsi
je 0x39df
movb 0x80(%rsp,%rsi), %r8b
andb %dl, %r8b
xorb %r8b, (%rax,%rsi)
incq %rsi
jmp 0x39c2
incq %rcx
incq %rax
jmp 0x39b0
movl $0x80, %eax
leaq -0x1(%rax), %rcx
testl %ecx, %ecx
js 0x3a14
movb -0x1(%rsp,%rax), %dl
movl %ecx, %esi
xorb %dl, -0x80(%rsp,%rsi)
xorb %dl, -0x80(%rsp,%rax)
xorb %dl, -0x7f(%rsp,%rax)
xorb %dl, -0x7a(%rsp,%rax)
movb $0x0, -0x1(%rsp,%rax)
movq %rcx, %rax
jmp 0x39ec
xorl %eax, %eax
cmpq $0x10, %rax
je 0x3a25
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x3a16
xorl %eax, %eax
cmpq $0x80, %rax
je 0x3a49
movb -0x80(%rsp,%rax), %dl
movl %eax, %ecx
notb %cl
andb $0x7, %cl
shlb %cl, %dl
movl %eax, %ecx
shrl $0x3, %ecx
orb %dl, (%rdi,%rcx)
incq %rax
jmp 0x3a27
addq $0x188, %rsp            # imm = 0x188
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x68, %rsp
andq $0x0, 0x450(%rdi)
vxorps %xmm0, %xmm0, %xmm0
leaq 0x20(%rsp), %rax
vmovaps %xmm0, (%rax)
leaq 0x40(%rsp), %rbp
vmovaps %xmm0, (%rbp)
movq %rdx, %r12
movq %rsi, %r13
leaq 0x30(%rsp), %rcx
vmovaps %xmm0, (%rcx)
vmovups %xmm0, 0x440(%rdi)
leaq 0x440(%rdi), %r14
movb $-0x80, (%rbp)
movb $0x40, (%rax)
movq %rdi, 0x8(%rsp)
leaq 0x3f0(%rdi), %rax
movq %rax, (%rsp)
cmpq $0x11, %r12
jb 0x3c2c
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
callq 0x1030
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1100
movq %rbx, %rdi
leaq 0x50(%rsp), %rbx
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
callq 0x1050
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1100
addq $-0x10, %r12
movq %rbp, %rdi
movq %rbp, %rsi
leaq 0x20(%rsp), %rdx
callq 0x1030
addq $0x10, %r13
jmp 0x3bc2
cmpq $0x10, %r12
jne 0x3c42
vmovups (%r13), %xmm0
vmovaps %xmm0, 0x10(%rsp)
movb $-0x40, %al
jmp 0x3c62
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
vmovaps %xmm0, (%rdi)
movq %r13, %rsi
movq %r12, %rdx
callq 0x1110
movb $-0x80, 0x10(%rsp,%r12)
movb $-0x60, %al
leaq 0x20(%rsp), %rdx
movb %al, (%rdx)
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x1030
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x1030
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1100
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1100
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x1050
vmovups (%r14), %xmm0
vmovups %xmm0, 0x420(%rbx)
vmovups (%r14), %xmm0
vmovups %xmm0, 0x430(%rbx)
addq $0x68, %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/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, %r15
movq %rdi, %rbx
leaq 0x420(%rdi), %r12
leaq 0x1e8(%rdi), %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x10f0
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1100
movq %rsp, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1050
leaq 0x430(%rbx), %r12
leaq 0x2dc(%rbx), %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1100
vmovaps (%r15), %xmm0
vmovups %xmm0, 0x430(%rbx)
subq $-0x80, 0x450(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %rbx
leaq 0x430(%rdi), %r12
leaq 0x2dc(%rdi), %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x10f0
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1100
leaq 0xf4(%rbx), %rdx
movq %rsp, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x10b0
leaq 0x420(%rbx), %r12
leaq 0x1e8(%rbx), %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1100
vmovaps (%r15), %xmm0
vmovups %xmm0, 0x420(%rbx)
subq $-0x80, 0x450(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %r15
leaq 0x8(%rsp), %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1303
movq %rbx, %rdi
movq %r14, %rdx
callq 0x131a
movl %eax, %ecx
testl %eax, %eax
jne 0x12fd
movq 0x8(%rsp), %rsi
incq 0x10(%rsi)
movq %rbx, %rdi
callq 0x13fc
movl %eax, %ecx
testl %ecx, %ecx
js 0x12d1
jmp 0x130e
xorl %ecx, %ecx
xorl %eax, %eax
lock
cmpxchgq %r15, (%rbx)
jne 0x12d1
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rsi, %r14
movq %rdi, %r12
cmpq $0x1, %rsi
ja 0x13cc
pushq $0x70
popq %rdi
callq 0x1110
movq %rax, (%r15)
testq %rax, %rax
je 0x13e8
movq %rax, %rbx
movw $0x100, (%rax)          # imm = 0x100
movq $0x1, 0x10(%rax)
andq $0x0, 0x8(%rax)
leaq 0x18(%rax), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x11a0
movl %eax, %ebp
testl %eax, %eax
jne 0x13c2
movq %rbx, %r13
addq $0x40, %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x10f0
movl %eax, %ebp
testl %eax, %eax
jne 0x13ba
movq %r15, %rdi
callq 0x11b0
movl %eax, %ebp
testl %eax, %eax
jne 0x13b2
xorl %ebp, %ebp
movq %r14, %rax
lock
cmpxchgq %rbx, (%r12)
je 0x13eb
movq %r15, %rdi
callq 0x1100
pushq $-0x1
popq %rbp
movq %r13, %rdi
callq 0x1160
movq %r15, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1030
jmp 0x13eb
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x156f
pushq $0xc
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq