LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/main.c
// Function: draw_char
void
draw_char(Font *font, GIF *gif, uint16_t code, uint8_t pair, int row, int col)
{
    int i, j;
    int x, y;
    int index;
    int pixel;
    uint8_t *strip;

    index = get_index(font, code);
    if (index == -1)
        return;
    strip = &font->data[font->stride * font->header.h * index];
    y = font->header.h * row;
    for (i = 0; i < font->header.h; i++) {
        x = font->header.w * col;
        for (j = 0; j < font->header.w; j++) {
            pixel = strip[j >> 3] & (1 << (7 - (j & 7)));
            gif->cur[y * gif->w + x] = pixel ? pair >> 4 : pair & 0xF;
            x++;
        }
        y++;
        strip += font->stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movw %dx, %cx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movb %al, -0x13(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x4810
movl %eax, -0x30(%rbp)
cmpl $-0x1, -0x30(%rbp)
jne 0x55ff
jmp 0x5727
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzbl 0x3(%rdx), %edx
imull %edx, %ecx
imull -0x30(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
cmpl %ecx, %eax
jge 0x5727
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x56fb
movq -0x40(%rbp), %rax
movl -0x24(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl -0x24(%rbp), %edx
andl $0x7, %edx
movl $0x7, %ecx
subl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x56b7
movzbl -0x13(%rbp), %eax
sarl $0x4, %eax
movl %eax, -0x44(%rbp)
jmp 0x56c1
movzbl -0x13(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rsi
movzwl (%rsi), %esi
imull %esi, %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5666
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x563d
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/main.c
// Function: render
void
render(Term *term, Font *font, GIF *gif, uint16_t delay)
{
    int i, j;
    uint16_t code;
    uint8_t pair;

    for (i = 0; i < term->rows; i++) {
        for (j = 0; j < term->cols; j++) {
            code = term->addr[i][j].code;
            pair = get_pair(term, i, j);
            draw_char(font, gif, code, pair, i, j);
        }
    }

    if (term->plt_local)
        gif->plt = term->plt;
    else
        gif->plt = 0;
    gif->plt_dirty |= term->plt_dirty;
    term->plt_dirty = 0;

    add_frame(gif, delay);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x57db
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x57cb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movw (%rax,%rcx,4), %ax
movw %ax, -0x26(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x5460
movb %al, -0x27(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movw -0x26(%rbp), %cx
movb -0x27(%rbp), %al
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movzwl %cx, %edx
movzbl %al, %ecx
callq 0x55c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5764
jmp 0x57cd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5752
movq -0x8(%rbp), %rax
cmpb $0x0, 0x19c(%rax)
je 0x57fd
movq -0x8(%rbp), %rcx
addq $0x16c, %rcx            # imm = 0x16C
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x5809
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movzbl 0x19d(%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0x2c(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x2c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x19d(%rax)
movq -0x18(%rbp), %rdi
movzwl -0x1a(%rbp), %esi
callq 0x4b20
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/main.c
// Function: set_defaults
void
set_defaults()
{
    options.height = 0;
    options.width = 0;
    options.output = "con.gif";
    options.maxdelay = FLT_MAX;
    options.divisor = 1.0;
    options.loop = -1;
    options.font = 0;
    options.cursor = 1;
    options.quiet = 0;
    options.barsize = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x8812(%rip)      # 0xe830
movl $0x0, 0x880c(%rip)      # 0xe834
leaq 0x1b19(%rip), %rax      # 0x7b48
movq %rax, 0x87da(%rip)      # 0xe810
movss 0x174e(%rip), %xmm0     # 0x778c
movss %xmm0, 0x87d2(%rip)     # 0xe818
movss 0x173a(%rip), %xmm0     # 0x7788
movss %xmm0, 0x87c6(%rip)     # 0xe81c
movl $0xffffffff, 0x87c0(%rip) # imm = 0xFFFFFFFF
movq $0x0, 0x87bd(%rip) # 0xe828
movl $0x1, 0x87c3(%rip)      # 0xe838
movl $0x0, 0x87bd(%rip)      # 0xe83c
movl $0x0, 0x87b7(%rip)      # 0xe840
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchLeader
void punchLeader( int count )
{
  int 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x397b
movl $0xf0, %eax
movl %eax, -0xc(%rbp)
jmp 0x3981
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpq $0x0, 0x9b81(%rip)      # 0xd510
je 0x39be
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x39bc
movq 0x9b69(%rip), %rsi      # 0xd510
movl $0x80, %edi
callq 0x20e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3998
jmp 0x39be
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchChecksum
void punchChecksum()
{
  /* If the assembler has output any BIN data output the checksum.            */
  if( binary_data_output && !rim_mode )
  {
    punchLocObject( 0, checksum );
  }
  binary_data_output = FALSE;
  checksum = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x99cd(%rip), %eax      # 0xd3a8
cmpl $0x0, %eax
je 0x39f7
cmpb $0x0, 0x99c6(%rip)      # 0xd3ad
jne 0x39f7
xorl %edi, %edi
movswl 0x9a7e(%rip), %esi      # 0xd470
callq 0x8250
movb $0x0, 0x99aa(%rip)      # 0xd3a8
movw $0x0, 0x9a69(%rip)      # 0xd470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: clearLiteralTable
void clearLiteralTable()
{
  int i;

  for (i = 0; i < DIM(cp); i++)
  {
    cp[i].loc = 0200;             /* Points to end of page for [] operands.  */
    cp[i].last_punched = 0200;    /* Points to end of page for [] operands.  */
  }
  memset(max_page_used, 0, sizeof(max_page_used));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x20, %rax
jae 0x40c9
movslq -0x4(%rbp), %rcx
leaq 0x962c(%rip), %rax      # 0xd6c0
imulq $0x104, %rcx, %rcx      # imm = 0x104
addq %rcx, %rax
movw $0x80, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x9612(%rip), %rax      # 0xd6c0
imulq $0x104, %rcx, %rcx      # imm = 0x104
addq %rcx, %rax
movw $0x80, 0x2(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x407f
leaq 0xb670(%rip), %rdi      # 0xf740
xorl %esi, %esi
movl $0x80, %edx
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: endOfBinary
void endOfBinary()
{
  /* Punch page 0 also.                                   */
  punchLiteralPool( cp, 1 );
  if( error_in_line )
  {
    listed = TRUE;
    clc = ( clc & 070000 ) + (( clc - 1 ) & 07777 );
    errorMessage( &end_of_file, -1 );
    clc = ( clc & 070000 ) + (( clc + 1 ) & 07777 );
  }
  else
  {
    listLine();             /* List line if not done yet.                     */
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9185(%rip), %rdi      # 0xd6c0
movl $0x1, %esi
callq 0x4a40
cmpb $0x0, 0xb32c(%rip)      # 0xf878
je 0x45b2
movb $0x1, 0xb273(%rip)      # 0xf7c8
movswl 0xb264(%rip), %eax      # 0xf7c0
andl $0x7000, %eax           # imm = 0x7000
movswl 0xb258(%rip), %ecx      # 0xf7c0
subl $0x1, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
addl %ecx, %eax
movw %ax, 0xb246(%rip)       # 0xf7c0
leaq 0x8cc7(%rip), %rdi      # 0xd248
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6ed0
movswl 0xb22e(%rip), %eax      # 0xf7c0
andl $0x7000, %eax           # imm = 0x7000
movswl 0xb222(%rip), %ecx      # 0xf7c0
addl $0x1, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
addl %ecx, %eax
movw %ax, 0xb210(%rip)       # 0xf7c0
jmp 0x45b7
callq 0x7f20
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: lexemeToName
char *lexemeToName( char *name, int from, int term )
{
  int  to;

  to = 0;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x15(%rbp)
jge 0x4fc0
cmpl $0x6, -0x14(%rbp)
setl %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x4fc9
jmp 0x5000
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0xa812(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %edi
callq 0x2070
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x4fa9
jmp 0x5002
cmpl $0x7, -0x14(%rbp)
jge 0x5020
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x5002
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: errorSymbol
void errorSymbol( EMSG_T *mesg, char *name, int col )
{
  char   linecol[12];
  char  *s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2, 0x8406(%rip)      # 0xd450
jne 0x50e6
cmpq $0x0, -0x10(%rbp)
jne 0x5064
leaq 0x47c4(%rip), %rax      # 0x9822
movq %rax, -0x30(%rbp)
jmp 0x506c
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x83ce(%rip), %eax      # 0xd448
addl $0x1, %eax
movl %eax, 0x83c5(%rip)      # 0xd448
leaq -0x20(%rbp), %rdi
movl 0xa73f(%rip), %edx      # 0xf7cc
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
leaq 0x4ad7(%rip), %rsi      # 0x9b71
movb $0x0, %al
callq 0x2180
movq 0x8398(%rip), %rdi      # 0xd440
leaq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x28(%rbp), %r9
movswl 0xa701(%rip), %eax      # 0xf7c0
leaq 0x4ab3(%rip), %rsi      # 0x9b79
leaq 0x8573(%rip), %rdx      # 0xd640
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x8530
movb $0x1, 0xa78b(%rip)      # 0xf878
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: nextLexBlank
void nextLexBlank()
{
  nextLexeme();
  if( is_blank( delimiter ))
  {
    errorMessage( &illegal_blank, lexstart - 1 );
  }
  delimiter = line[lexterm];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4330
movsbl 0xa6d0(%rip), %eax      # 0xf880
cmpl $0x20, %eax
je 0x51d9
movsbl 0xa6c4(%rip), %eax      # 0xf880
cmpl $0x9, %eax
je 0x51d9
movsbl 0xa6b8(%rip), %eax      # 0xf880
cmpl $0xc, %eax
je 0x51d9
movsbl 0xa6ac(%rip), %eax      # 0xf880
cmpl $0x3e, %eax
jne 0x51ee
movl 0xa695(%rip), %esi      # 0xf874
subl $0x1, %esi
leaq 0x7f2f(%rip), %rdi      # 0xd118
callq 0x6ed0
movslq 0xa687(%rip), %rcx      # 0xf87c
leaq 0xa5f4(%rip), %rax      # 0xf7f0
movb (%rax,%rcx), %al
movb %al, 0xa67b(%rip)       # 0xf880
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: evalSymbol
SYM_T *evalSymbol()
{
  char   name[SYMLEN];
  SYM_T *sym;

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

  /* The symbol goes in the concordance iff it is in a different position in  */
  /* the assembler source file.                                               */
  if( lexstart != last_xref_lexstart ||  lineno != last_xref_lineno )
  {
    sym->xref_count++;          /* Count the number of references to symbol.  */
    last_xref_lexstart = lexstart;
    last_xref_lineno = lineno;

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

  return( sym );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x7(%rbp), %rdi
movl 0xa492(%rip), %esi      # 0xf874
movl 0xa494(%rip), %edx      # 0xf87c
callq 0x4f90
movq %rax, %rdi
callq 0x4dd0
movq %rax, -0x10(%rbp)
movl 0xa475(%rip), %eax      # 0xf874
cmpl 0xa3d3(%rip), %eax      # 0xf7d8
jne 0x5415
movl 0xa3bf(%rip), %eax      # 0xf7cc
cmpl 0xa3c9(%rip), %eax      # 0xf7dc
je 0x5476
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movl 0xa44c(%rip), %eax      # 0xf874
movl %eax, 0xa3aa(%rip)      # 0xf7d8
movl 0xa398(%rip), %eax      # 0xf7cc
movl %eax, 0xa3a2(%rip)      # 0xf7dc
movzbl 0x7f70(%rip), %eax      # 0xd3b1
cmpl $0x0, %eax
je 0x5474
cmpl $0x2, 0x8003(%rip)      # 0xd450
jne 0x5474
movl 0xa377(%rip), %eax      # 0xf7cc
movw %ax, %dx
movq 0x8151(%rip), %rax      # 0xd5b0
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movq -0x10(%rbp), %rsi
addl 0x14(%rsi), %ecx
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x5476
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: incrementClc
WORD16 incrementClc()
{
  testForLiteralCollision( clc );

  /* Incrementing the location counter is not to change field setting.        */
  clc = ( clc & 070000 ) + (( clc + 1 ) & 07777 );
  fieldlc = clc & 07777;
  return( clc );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movswl 0x9055(%rip), %edi      # 0xf7c0
callq 0x7e60
movswl 0x9049(%rip), %eax      # 0xf7c0
andl $0x7000, %eax           # imm = 0x7000
movswl 0x903d(%rip), %ecx      # 0xf7c0
addl $0x1, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
addl %ecx, %eax
movw %ax, 0x902b(%rip)       # 0xf7c0
movswl 0x9024(%rip), %eax      # 0xf7c0
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x901c(%rip)       # 0xf7c4
movw 0x9011(%rip), %ax       # 0xf7c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: insertLiteral
WORD16 insertLiteral( LPOOL_T *pool, WORD16 value, int fieldpage_index )
{
  WORD16  ix;
  LPOOL_T *p;

  p = &pool[fieldpage_index];

  /* Search the literal pool for any occurence of the needed value.           */
  ix = PAGE_SIZE - 1;
  while( ix >= p->loc && p->pool[ix] != value )
  {
    ix--;
  }

  /* Check if value found in literal pool. If not, then insert value.         */
  if( ix < p->loc )
  {
    (p->loc)--;
    p->pool[p->loc] = value;
    ix = p->loc;
    if( max_page_used[fieldpage_index] >= p->loc ) {
      if ( (fieldpage_index & 017) == 0 )
      {
        errorMessage( &pz_literal_overflow, -1 );
      }
      else
      {
        errorMessage( &literal_overflow, -1 );
      }
    }
  }
  return( ix );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x104, %rcx, %rcx      # imm = 0x104
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movw $0x7f, -0x12(%rbp)
movswl -0x12(%rbp), %ecx
movq -0x20(%rbp), %rax
movswl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jl 0x6970
movq -0x20(%rbp), %rax
movswq -0x12(%rbp), %rcx
movswl 0x4(%rax,%rcx,2), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6979
jmp 0x6987
movw -0x12(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x6942
movswl -0x12(%rbp), %eax
movq -0x20(%rbp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x6a10
movq -0x20(%rbp), %rax
movw (%rax), %cx
addw $-0x1, %cx
movw %cx, (%rax)
movw -0xa(%rbp), %dx
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movswq (%rcx), %rcx
movw %dx, 0x4(%rax,%rcx,2)
movq -0x20(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x12(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x8d71(%rip), %rax      # 0xf740
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jl 0x6a0e
movl -0x10(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x69fb
leaq 0x6809(%rip), %rdi      # 0xd1f8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6ed0
jmp 0x6a0c
leaq 0x67e6(%rip), %rdi      # 0xd1e8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6ed0
jmp 0x6a0e
jmp 0x6a10
movw -0x12(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: errorMessage
void errorMessage( EMSG_T *mesg, int col )
{
  char   linecol[12];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, 0x656a(%rip)      # 0xd450
jne 0x6f54
movl 0x655a(%rip), %eax      # 0xd448
addl $0x1, %eax
movl %eax, 0x6551(%rip)      # 0xd448
leaq -0x18(%rbp), %rdi
movl 0x88cb(%rip), %edx      # 0xf7cc
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
leaq 0x2c63(%rip), %rsi      # 0x9b71
movb $0x0, %al
callq 0x2180
movq 0x6524(%rip), %rdi      # 0xd440
leaq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movswl 0x8890(%rip), %r9d      # 0xf7c0
leaq 0x2c6b(%rip), %rsi      # 0x9ba2
leaq 0x6702(%rip), %rdx      # 0xd640
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x8530
movb $0x1, 0x891d(%rip)      # 0xf878
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: moveToEndOfLine
void moveToEndOfLine()
{
  while( !isend( line[cc] )) cc++;
  lexstart = cc;
  lexterm = cc;
  lexstartprev = lexstart;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x6f76
movslq 0x890f(%rip), %rcx      # 0xf88c
leaq 0x886c(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
je 0x6fad
movslq 0x88f3(%rip), %rcx      # 0xf88c
leaq 0x8850(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6fb8
jmp 0x6fc9
movl 0x88ce(%rip), %eax      # 0xf88c
addl $0x1, %eax
movl %eax, 0x88c5(%rip)      # 0xf88c
jmp 0x6f76
movl 0x88bd(%rip), %eax      # 0xf88c
movl %eax, 0x889f(%rip)      # 0xf874
movl 0x88b1(%rip), %eax      # 0xf88c
movl %eax, 0x889b(%rip)      # 0xf87c
movl 0x888d(%rip), %eax      # 0xf874
movl %eax, 0x8897(%rip)      # 0xf884
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: getDublExprs
WORD32 getDublExprs()
{
  WORD32 dublvalue;

  dublvalue = getDublExpr();

  while( TRUE )
  {
    if( isdone( line[lexstart] ))
    {
      return( dublvalue );
    }
    else
    {
      errorMessage( &illegal_expression, lexstart - 1 );
      return( 0 );
    }
  } /* end while                                                              */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x7210
movq %rax, -0x10(%rbp)
movslq 0x86ec(%rip), %rcx      # 0xf874
leaq 0x8661(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x71dd
movslq 0x86d5(%rip), %rcx      # 0xf874
leaq 0x864a(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x71dd
movslq 0x86be(%rip), %rcx      # 0xf874
leaq 0x8633(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x71dd
movslq 0x86a7(%rip), %rcx      # 0xf874
leaq 0x861c(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x71e7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7204
movl 0x8687(%rip), %esi      # 0xf874
subl $0x1, %esi
leaq 0x5f41(%rip), %rdi      # 0xd138
callq 0x6ed0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: evalDubl
WORD32 evalDubl( WORD32 initial_value )
{
  WORD32  digit;
  int     from;
  WORD32  dublvalue;
  WORD32  olddublvalue;

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

  while( from < lexterm )
  {
    if( isdigit( 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, 0x8411(%rip)      # 0xf894
movslq 0x83f2(%rip), %rcx      # 0xf87c
leaq 0x835f(%rip), %rax      # 0xf7f0
movb (%rax,%rcx), %al
movb %al, 0x83e6(%rip)       # 0xf880
movl 0x83d4(%rip), %eax      # 0xf874
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x83c8(%rip), %eax      # 0xf87c
jge 0x7551
callq 0x21b0
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
leaq 0x8323(%rip), %rcx      # 0xf7f0
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x752c
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0x82f1(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cltq
movq %rax, -0x10(%rbp)
imulq $0xa, -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x752a
movb $0x1, 0x836a(%rip)      # 0xf894
jmp 0x754c
movl -0x14(%rbp), %esi
leaq 0x5c22(%rip), %rdi      # 0xd158
callq 0x5150
movq $0x0, -0x20(%rbp)
movl 0x8333(%rip), %eax      # 0xf87c
movl %eax, -0x14(%rbp)
jmp 0x74ab
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: getFltgExprs
FLTG_T *getFltgExprs()
{
  FLTG_T *fltg;

  fltg = getFltgExpr();

  while( TRUE )
  {
    if( isdone( line[lexstart] ))
    {
      return( fltg );
    }
    else
    {
      errorMessage( &illegal_expression, lexstart - 1 );
      return( 0 );
    }
  } /* end while                                                              */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x77c0
movq %rax, -0x10(%rbp)
movslq 0x813c(%rip), %rcx      # 0xf874
leaq 0x80b1(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x778d
movslq 0x8125(%rip), %rcx      # 0xf874
leaq 0x809a(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x778d
movslq 0x810e(%rip), %rcx      # 0xf874
leaq 0x8083(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x778d
movslq 0x80f7(%rip), %rcx      # 0xf874
leaq 0x806c(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x7797
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x77b4
movl 0x80d7(%rip), %esi      # 0xf874
subl $0x1, %esi
leaq 0x5991(%rip), %rdi      # 0xd138
callq 0x6ed0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: normalizeFltg
void normalizeFltg( FLTG_T *fltg )
{
  /* Normalize the floating point number.                                     */
  if( fltg->mantissa != 0 )
  {
    if(( fltg->mantissa & ~0x3FFFFFFL ) == 0 )
    {
      while(( fltg->mantissa & ~0x1FFFFFFL ) == 0 )

      {
        fltg->mantissa <<= 1;
        fltg->exponent--;
      }
    }
    else
    {
      while(( fltg->mantissa & ~0x3FFFFFFL ) != 0 )
      {
        fltg->mantissa >>= 1;
        fltg->exponent++;
      }
    }
  }
  else
  {
    fltg->exponent = 0;
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7e4b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x4000000, %rax       # imm = 0xFC000000
cmpq $0x0, %rax
jne 0x7e12
jmp 0x7ddd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x2000000, %rax       # imm = 0xFE000000
cmpq $0x0, %rax
jne 0x7e10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $-0x1, %cx
movw %cx, (%rax)
jmp 0x7ddd
jmp 0x7e49
jmp 0x7e14
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x4000000, %rax       # imm = 0xFC000000
cmpq $0x0, %rax
je 0x7e47
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
sarq %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
jmp 0x7e14
jmp 0x7e49
jmp 0x7e54
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: testForLiteralCollision
BOOL testForLiteralCollision( WORD16 loc )
{
  WORD16  pagelc;
  BOOL    result = FALSE;
  WORD16  tmppage;
  int     tmpfield;

  tmpfield = GET_PAGE_INDEX(loc);
  tmppage = loc & 07600;
  pagelc  = loc & 00177;

  if ( pagelc > max_page_used[tmpfield] ) 
  {
     max_page_used[tmpfield] = pagelc;
  }
  if ( pagelc >= cp[tmpfield].loc )
  {
    if ( tmppage == 0 )
    {
      errorMessage( &pz_literal_overflow, -1 );
    }
    else
    {
      errorMessage( &literal_overflow, -1 );
    }
    result = TRUE;
  }

  return( result );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movb $0x0, -0x5(%rbp)
movswl -0x2(%rbp), %eax
andl $0xf80, %eax            # imm = 0xF80
sarl $0x7, %eax
movl %eax, -0xc(%rbp)
movswl -0x2(%rbp), %eax
andl $0xf80, %eax            # imm = 0xF80
movw %ax, -0x8(%rbp)
movswl -0x2(%rbp), %eax
andl $0x7f, %eax
movw %ax, -0x4(%rbp)
movswl -0x4(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x7897(%rip), %rcx      # 0xf740
cmpl (%rcx,%rdx,4), %eax
jle 0x7ec0
movswl -0x4(%rbp), %edx
movslq -0xc(%rbp), %rcx
leaq 0x7883(%rip), %rax      # 0xf740
movl %edx, (%rax,%rcx,4)
movswl -0x4(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x57f1(%rip), %rcx      # 0xd6c0
imulq $0x104, %rdx, %rdx      # imm = 0x104
addq %rdx, %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
jl 0x7f11
movswl -0x8(%rbp), %eax
cmpl $0x0, %eax
jne 0x7efc
leaq 0x5308(%rip), %rdi      # 0xd1f8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6ed0
jmp 0x7f0d
leaq 0x52e5(%rip), %rdi      # 0xd1e8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6ed0
movb $0x1, -0x5(%rbp)
movb -0x5(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: printPageBreak
void printPageBreak()
{
  if( page_lineno >= LIST_LINES_PER_PAGE )
         /*  ( list_lineno % LIST_LINES_PER_PAGE ) == 0 ) */
  {
    if( !list_title_set )
    {
      /* strcpy( list_title, line ); */
      if( list_title[strlen(list_title) - 1] == '\n' )
      {
        list_title[strlen(list_title) - 1] = '\0';
      }
      if( strlen( list_title ) > TITLELEN )
      {
        list_title[TITLELEN] = '\0';
      }
      list_title_set = TRUE;
    }
    topOfForm( list_title, NULL );

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x37, 0x5519(%rip)     # 0xd474
jl 0x7fd7
cmpb $0x0, 0x787c(%rip)      # 0xf7e0
jne 0x7fc7
leaq 0x7943(%rip), %rdi      # 0xf8b0
callq 0x20a0
movq %rax, %rcx
subq $0x1, %rcx
leaq 0x7930(%rip), %rax      # 0xf8b0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x7fa7
leaq 0x7920(%rip), %rdi      # 0xf8b0
callq 0x20a0
movq %rax, %rcx
subq $0x1, %rcx
leaq 0x790d(%rip), %rax      # 0xf8b0
movb $0x0, (%rax,%rcx)
leaq 0x7902(%rip), %rdi      # 0xf8b0
callq 0x20a0
cmpq $0x3f, %rax
jbe 0x7fc0
movb $0x0, 0x792f(%rip)      # 0xf8ef
movb $0x1, 0x7819(%rip)      # 0xf7e0
leaq 0x78e2(%rip), %rdi      # 0xf8b0
xorl %eax, %eax
movl %eax, %esi
callq 0x7fe0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: topOfForm
void topOfForm( char *title, char *sub_title )
{
  char temp[10];

  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\n\n      %-63s %10s\n", title, temp );

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x77da(%rip), %eax      # 0xf7d0
addl $0x1, %eax
movl %eax, 0x77d1(%rip)      # 0xf7d0
leaq -0x1a(%rbp), %rdi
leaq 0x50b7(%rip), %rsi      # 0xd0c1
callq 0x2060
leaq -0x1a(%rbp), %rdi
movl 0x77b7(%rip), %ecx      # 0xf7d0
leaq 0x1b29(%rip), %rsi      # 0x9b49
leaq 0x509a(%rip), %rdx      # 0xd0c1
movb $0x0, %al
callq 0x2180
cmpl $0x1, 0x779b(%rip)      # 0xf7d0
jle 0x804c
movq 0x5562(%rip), %rdi      # 0xd5a0
leaq 0x1b0a(%rip), %rsi      # 0x9b4f
movb $0x0, %al
callq 0x2120
movq 0x554d(%rip), %rdi      # 0xd5a0
movq -0x8(%rbp), %rdx
leaq -0x1a(%rbp), %rcx
leaq 0x1aef(%rip), %rsi      # 0x9b51
movb $0x0, %al
callq 0x2120
movl $0x3, 0x5401(%rip)      # 0xd474
cmpq $0x0, -0x10(%rbp)
je 0x80a4
movq 0x551f(%rip), %rdi      # 0xd5a0
movq -0x10(%rbp), %rdx
leaq 0x1ada(%rip), %rsi      # 0x9b66
movb $0x0, %al
callq 0x2120
movl 0x53db(%rip), %eax      # 0xd474
addl $0x1, %eax
movl %eax, 0x53d2(%rip)      # 0xd474
jmp 0x80c8
movq 0x54f5(%rip), %rdi      # 0xd5a0
leaq 0x176f(%rip), %rsi      # 0x9821
movb $0x0, %al
callq 0x2120
movl 0x53b5(%rip), %eax      # 0xd474
addl $0x1, %eax
movl %eax, 0x53ac(%rip)      # 0xd474
movq 0x54d1(%rip), %rdi      # 0xd5a0
leaq 0x174b(%rip), %rsi      # 0x9821
movb $0x0, %al
callq 0x2120
movl 0x5391(%rip), %eax      # 0xd474
addl $0x1, %eax
movl %eax, 0x5388(%rip)      # 0xd474
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: printErrorMessages
void printErrorMessages()
{
  WORD16  ix;
  WORD16  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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x5490(%rip)      # 0xd5a0
je 0x823b
movw $0x0, -0x4(%rbp)
movswl -0x4(%rbp), %eax
cmpl 0x5326(%rip), %eax      # 0xd44c
jge 0x8239
callq 0x7f50
movq 0x5468(%rip), %rdi      # 0xd5a0
movswq -0x4(%rbp), %rcx
leaq 0x77fc(%rip), %rax      # 0xf940
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x1936(%rip), %rsi      # 0x9a8b
movb $0x0, %al
callq 0x2120
movswq -0x4(%rbp), %rcx
leaq 0x77d8(%rip), %rax      # 0xf940
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jl 0x8215
movw $0x0, -0x2(%rbp)
movswl -0x2(%rbp), %eax
movswq -0x4(%rbp), %rdx
leaq 0x77b1(%rip), %rcx      # 0xf940
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0x81e4
movswq -0x2(%rbp), %rcx
leaq 0x7649(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x81c3
movq 0x53e9(%rip), %rsi      # 0xd5a0
movl $0x9, %edi
callq 0x2100
jmp 0x81d4
movq 0x53d6(%rip), %rsi      # 0xd5a0
movl $0x20, %edi
callq 0x2100
jmp 0x81d6
movw -0x2(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x2(%rbp)
jmp 0x817f
movq 0x53b5(%rip), %rsi      # 0xd5a0
leaq 0x18a2(%rip), %rdi      # 0x9a94
callq 0x20c0
movl 0x75d7(%rip), %eax      # 0xf7d4
addl $0x1, %eax
movl %eax, 0x75ce(%rip)      # 0xf7d4
movl 0x5268(%rip), %eax      # 0xd474
addl $0x1, %eax
movl %eax, 0x525f(%rip)      # 0xd474
movq 0x5384(%rip), %rsi      # 0xd5a0
leaq 0x15fe(%rip), %rdi      # 0x9821
callq 0x20c0
movw -0x4(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x4(%rbp)
jmp 0x811c
jmp 0x823b
movl $0x0, 0x5207(%rip)      # 0xd44c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchLocObject
void punchLocObject( WORD16 loc, WORD16 val )
{
  if( rim_mode )
  {
    punchOrigin( loc );
  }
  punchObject(( val >> 6 ) & 0077 );
  punchObject( val & 0077 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
cmpb $0x0, 0x5140(%rip)      # 0xd3ad
je 0x8278
movswl -0x2(%rbp), %edi
callq 0x40f0
movswl -0x4(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
movswl %ax, %edi
callq 0x82a0
movswl -0x4(%rbp), %eax
andl $0x3f, %eax
movswl %ax, %edi
callq 0x82a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchObject
void punchObject( WORD16 val )
{
  val &= 0377;
  if( objectfile != NULL )
  {
    fputc( val, objectfile );
    checksum += val;
  }
  binary_data_output = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %eax
andl $0xff, %eax
movw %ax, -0x2(%rbp)
cmpq $0x0, 0x524c(%rip)      # 0xd510
je 0x82ea
movswl -0x2(%rbp), %edi
movq 0x523f(%rip), %rsi      # 0xd510
callq 0x20e0
movswl -0x2(%rbp), %ecx
movswl 0x518f(%rip), %eax      # 0xd470
addl %ecx, %eax
movw %ax, 0x5186(%rip)       # 0xd470
movb $0x1, 0x50b7(%rip)      # 0xd3a8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: binarySearch
int binarySearch( char *name, int start, int symbol_count )
{
  int     lx;                   /* Left index                                 */
  int     mx;                   /* Middle index                               */
  int     rx;                   /* Right index                                */
  int     compare;              /* Results of comparison                      */

  lx = start;
  rx = symbol_count - 1;
  while( lx <= rx )
  {
    mx = ( lx + rx ) / 2;   /* Find center of search area.                    */

    compare = strcmp( name, symtab[mx].name );

    if( compare < 0 )
    {
      rx = mx - 1;
    }
    else if( compare > 0 )
    {
      lx = mx + 1;
    }
    else
    {
      return( mx );         /* Found a match in symbol table.                 */
    }
  } /* end while                                                              */
  return( ~lx );            /* Return insertion point.                        */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x838a
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0x5113(%rip), %rsi      # 0xd458
movslq -0x20(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x2110
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x836d
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8388
cmpl $0x0, -0x28(%rbp)
jle 0x837e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8386
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8393
jmp 0x8388
jmp 0x8321
movl -0x1c(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: conditionTrue
void conditionTrue()
{
  if( line[lexstart] == '<' )
  {
    nextLexeme();               /* Skip the opening '<'                       */
  }
  else
  {
    errorMessage( &lt_expected, lexstart );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x7499(%rip), %rcx      # 0xf874
leaq 0x740e(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x83f2
callq 0x4330
jmp 0x8404
movl 0x747c(%rip), %esi      # 0xf874
leaq 0x4eb9(%rip), %rdi      # 0xd2b8
callq 0x6ed0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: conditionFalse
void conditionFalse()
{
  int     level;

  if( line[lexstart] == '<' )
  {
    /* Invariant: line[cc] is the next unexamined character.                  */
    level = 1;
    while( level > 0 )
    {
      if( isend( 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
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0x7455(%rip), %rcx      # 0xf874
leaq 0x73ca(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x8515
movl $0x1, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x850e
movslq 0x7441(%rip), %rcx      # 0xf88c
leaq 0x739e(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x8472
movslq 0x742a(%rip), %rcx      # 0xf88c
leaq 0x7387(%rip), %rax      # 0xf7f0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x847c
callq 0x4130
jmp 0x8509
movslq 0x7409(%rip), %rax      # 0xf88c
leaq 0x7366(%rip), %rcx      # 0xf7f0
movsbl (%rax,%rcx), %eax
movl %eax, -0x8(%rbp)
subl $0x24, %eax
je 0x84e0
jmp 0x8498
movl -0x8(%rbp), %eax
subl $0x3c, %eax
je 0x84c6
jmp 0x84a2
movl -0x8(%rbp), %eax
subl $0x3e, %eax
jne 0x84f8
jmp 0x84ac
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movl 0x73d1(%rip), %eax      # 0xf88c
addl $0x1, %eax
movl %eax, 0x73c8(%rip)      # 0xf88c
jmp 0x8507
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl 0x73b7(%rip), %eax      # 0xf88c
addl $0x1, %eax
movl %eax, 0x73ae(%rip)      # 0xf88c
jmp 0x8507
movl $0x0, -0x4(%rbp)
movl 0x739f(%rip), %eax      # 0xf88c
addl $0x1, %eax
movl %eax, 0x7396(%rip)      # 0xf88c
jmp 0x8507
movl 0x738e(%rip), %eax      # 0xf88c
addl $0x1, %eax
movl %eax, 0x7385(%rip)      # 0xf88c
jmp 0x8509
jmp 0x843a
callq 0x4330
jmp 0x8527
movl 0x7359(%rip), %esi      # 0xf874
leaq 0x4d96(%rip), %rdi      # 0xd2b8
callq 0x6ed0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: saveError
void saveError( char *mesg, int 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq 0x4f06(%rip), %rax      # 0xd44c
cmpq $0x14, %rax
jae 0x8592
movq -0x8(%rbp), %rcx
movslq 0x4ef5(%rip), %rdx      # 0xd44c
leaq 0x73e2(%rip), %rax      # 0xf940
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movslq 0x4eda(%rip), %rdx      # 0xd44c
leaq 0x73c7(%rip), %rax      # 0xf940
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl 0x4ec3(%rip), %eax      # 0xd44c
addl $0x1, %eax
movl %eax, 0x4eba(%rip)      # 0xd44c
movb $0x1, 0x72df(%rip)      # 0xf878
cmpb $0x0, 0x7228(%rip)      # 0xf7c8
je 0x85a7
callq 0x8100
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/9-File/full_buf.c
// Function: main
int main(void)
{
	if(setvbuf(stdout, NULL, _IOFBF, 0) != 0)
	{
		perror("setvbuf");
		exit(1);
	}

	printf("H");	sleep(1);
	printf("E");	sleep(1);
	printf("L");	sleep(1);
	printf("L");	sleep(1);
	printf("O");	sleep(1);
	printf("\n");	sleep(1);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e4a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
xorl %edx, %edx
movq %rcx, %rsi
callq 0x1040
cmpl $0x0, %eax
je 0x11c2
leaq 0xe51(%rip), %rdi       # 0x2004
callq 0x1050
movl $0x1, %edi
callq 0x1060
leaq 0xe43(%rip), %rdi       # 0x200c
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xe2d(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xe17(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xdff(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xde9(%rip), %rdi       # 0x2012
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
leaq 0xdd3(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rouming[P]io/zmtp-test.c
// Function: create_signalfd
static int create_signalfd(void)
{
	sigset_t set;
	int fd;

	sigfillset(&set);
	sigprocmask(SIG_BLOCK, &set, NULL);

	sigemptyset(&set);
	sigaddset(&set, SIGINT);
	fd = signalfd(-1, &set, 0);
	assert(fd >= 0);

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x80(%rbp), %rdi
callq 0x1160
xorl %edi, %edi
leaq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1030
leaq -0x80(%rbp), %rdi
callq 0x1150
leaq -0x80(%rbp), %rdi
movl $0x2, %esi
callq 0x11f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0x80(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x84(%rbp)
cmpl $0x0, -0x84(%rbp)
jl 0x164b
jmp 0x166a
leaq 0x5ac8(%rip), %rdi      # 0x711a
leaq 0x5a90(%rip), %rsi      # 0x70e9
movl $0x42, %edx
leaq 0x5add(%rip), %rcx      # 0x7142
callq 0x10d0
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rouming[P]io/zmtp-test.c
// Function: init_loop_ctx
static void init_loop_ctx(struct loop_ctx *c, int sigfd, int ssock)
{
	int rc, i;

	memset(c, 0, sizeof(*c));
	INIT_LIST_HEAD(&c->peers_to_free);
	c->items[0] = (struct poller_item){
		.fd	= sigfd,
		.events = P_IN,
		.data	= NULL,
		.action = on_signal
	};
	c->items[1] = (struct poller_item){
		.fd	= ssock,
		.events = P_IN,
		.data	= c,
		.action = on_sock_connection
	};
	rc = poller_create(&c->poller);
	assert(rc == 0);
	for (i = 0; i < ARRAY_SIZE(c->items); i++) {
		rc = poller_ctl(c->poller, P_CTL_ADD, &c->items[i]);
		assert(rc == 0);
	}
	c->ssock = ssock;
	c->sigfd = sigfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x280, %edx            # imm = 0x280
callq 0x10e0
movq -0x8(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0x1950
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x288(%rbp)
leaq -0x148(%rbp), %rdi
xorl %esi, %esi
movl $0x130, %edx            # imm = 0x130
callq 0x10e0
movq -0x288(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x148(%rbp)
movl $0x2, -0x144(%rbp)
leaq 0x288(%rip), %rax       # 0x1980
movq %rax, -0x20(%rbp)
leaq -0x148(%rbp), %rsi
movl $0x130, %edx            # imm = 0x130
callq 0x1170
movq -0x8(%rbp), %rax
addq $0x10, %rax
addq $0x130, %rax            # imm = 0x130
movq %rax, -0x280(%rbp)
leaq -0x278(%rbp), %rdi
xorl %esi, %esi
movl $0x130, %edx            # imm = 0x130
callq 0x10e0
movq -0x280(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x278(%rbp)
movl $0x2, -0x274(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq 0x2ef(%rip), %rax       # 0x1a50
movq %rax, -0x150(%rbp)
leaq -0x278(%rbp), %rsi
movl $0x130, %edx            # imm = 0x130
callq 0x1170
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x64a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1791
jmp 0x17b0
leaq 0x59c4(%rip), %rdi      # 0x715c
leaq 0x594a(%rip), %rsi      # 0x70e9
movl $0x110, %edx            # imm = 0x110
leaq 0x59b9(%rip), %rcx      # 0x7164
callq 0x10d0
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x2, %rax
jae 0x181d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movslq -0x18(%rbp), %rax
imulq $0x130, %rax, %rax      # imm = 0x130
addq %rax, %rdx
xorl %esi, %esi
callq 0x6640
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x17f1
jmp 0x1810
leaq 0x5964(%rip), %rdi      # 0x715c
leaq 0x58ea(%rip), %rsi      # 0x70e9
movl $0x113, %edx            # imm = 0x113
leaq 0x5959(%rip), %rcx      # 0x7164
callq 0x10d0
jmp 0x1812
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x17b7
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
nopl (%rax)