LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/term.c
// Function: fake_colour_256
static int
fake_colour_256(int colnum){
    int nr, ng, nb;
    if (colnum < 16) {
        nr = (colnum&1) ? 170:0;
        ng = (colnum&2) ? 170:0;
        nb = (colnum&4) ? 170:0;
        if (colnum&8) { nr += 85; ng += 85; nb += 85; }
        if (colnum == 3) ng = 85;
    } else if (colnum < 232) {
        int i = colnum - 16;
        nr = i / 36; ng = (i / 6) % 6; nb = i % 6;
        nr = nr ? nr * 40 + 55 : 0;
        ng = ng ? ng * 40 + 55 : 0;
        nb = nb ? nb * 40 + 55 : 0;
    } else if (colnum < 256) {
        int i = colnum - 232;
        nr = ng = nb = i * 10 + 8;
    } else
        nr=ng=nb = 127;

    return fake_colour_16m(nr, ng, nb);
}

// Assembly:
cmpl $0xf, %edi
jg 0x2d4d
movl %edi, %ecx
andl $0x1, %ecx
negl %ecx
movl $0xaa, %eax
andl %eax, %ecx
movl %edi, %esi
shll $0x1e, %esi
sarl $0x1f, %esi
andl %eax, %esi
movl %edi, %r8d
shll $0x1d, %r8d
sarl $0x1f, %r8d
andl %eax, %r8d
leal 0x55(%rcx), %eax
leal 0x55(%rsi), %r9d
leal 0x55(%r8), %edx
testb $0x8, %dil
cmovel %r8d, %edx
cmovel %esi, %r9d
cmovel %ecx, %eax
cmpl $0x3, %edi
movl $0x55, %esi
cmovnel %r9d, %esi
jmp 0x2de7
cmpl $0xe7, %edi
ja 0x2dc2
addl $-0x10, %edi
movzbl %dil, %eax
imull $0x39, %eax, %ecx
shrl $0xb, %ecx
imull $0xab, %eax, %edx
shrl $0xa, %edx
imull $0x2b, %edx, %esi
shrl $0x7, %esi
andl $-0x2, %esi
leal (%rsi,%rsi,2), %esi
movl %edx, %r8d
subb %sil, %r8b
movzbl %r8b, %esi
addl %edx, %edx
leal (%rdx,%rdx,2), %edx
subb %dl, %al
movzbl %al, %edx
xorl %r8d, %r8d
cmpl $0x24, %edi
leal (%rcx,%rcx,4), %eax
leal 0x37(,%rax,8), %eax
cmovbl %r8d, %eax
testb %sil, %sil
leal (%rsi,%rsi,4), %ecx
leal 0x37(,%rcx,8), %esi
cmovel %r8d, %esi
testb %dl, %dl
leal (%rdx,%rdx,4), %ecx
leal 0x37(,%rcx,8), %edx
cmovel %r8d, %edx
jmp 0x2de7
movl $0x7f, %edx
movl $0x7f, %esi
movl $0x7f, %eax
cmpl $0xff, %edi
ja 0x2de7
leal (%rdi,%rdi,4), %eax
leal -0x908(,%rax,2), %edx
movl %edx, %esi
movl %edx, %eax
movl %eax, %edi
jmp 0x2deb
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/term.c
// Function: fake_colour_16m
static int
fake_colour_16m(int red, int green, int blue)
{
    int av = (red+green+blue)/3;
    int palno = 1*(red>=av) + 2*(green>=av) + 4*(blue>=av);
    if (red==green && green==blue) {
        if (av > 212) palno = 15-8;
        else if (av > 127) palno = 7-8;
        else if (av > 42) palno = 8;
        else palno = 0;
    }
    return palno + 8*(av>127);
}

// Assembly:
pushq %rbx
leal (%rsi,%rdi), %eax
addl %edx, %eax
movslq %eax, %rcx
imulq $0x55555556, %rcx, %rbx # imm = 0x55555556
movq %rbx, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rbx
addl %ecx, %ebx
xorl %ecx, %ecx
cmpl %edx, %ebx
setle %r8b
xorl %r9d, %r9d
cmpl %esi, %ebx
setle %r11b
xorl %r10d, %r10d
cmpl %edi, %ebx
setle %bl
xorl %esi, %edi
xorl %edx, %esi
orl %edi, %esi
jne 0x2e50
movl $0x7, %ecx
cmpl $0x27e, %eax            # imm = 0x27E
jg 0x2e60
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x17f, %eax            # imm = 0x17F
jg 0x2e60
xorl %ecx, %ecx
cmpl $0x81, %eax
setge %cl
shll $0x3, %ecx
jmp 0x2e60
movb %bl, %r10b
movb %r11b, %r9b
leal (%r10,%r9,2), %edx
movb %r8b, %cl
leal (%rdx,%rcx,4), %ecx
xorl %edx, %edx
cmpl $0x180, %eax            # imm = 0x180
setge %dl
leal (%rcx,%rdx,8), %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/mbf.c
// Function: search_glyph
int
search_glyph(Font *font, uint16_t code)
{
    int index, i;
    Range r;

    index = 0;
    for (i = 0; i < font->header.nr; i++) {
        r = font->ranges[i];
        if (code < r.offset)
            return -1;
        if (code < r.offset + r.length)
            return index + code - r.offset;
        index += r.length;
    }
    return -1;
}

// Assembly:
movzwl 0x4(%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x2fbd
pushq %rbx
movq 0x10(%rdi), %r8
movzwl %si, %edx
xorl %r9d, %r9d
xorl %edi, %edi
movzwl (%r8,%r9,4), %r10d
cmpw %si, %r10w
ja 0x2fbc
movzwl 0x2(%r8,%r9,4), %r11d
leal (%r11,%r10), %ebx
cmpl %edx, %ebx
ja 0x2fb5
addl %r11d, %edi
incq %r9
cmpq %r9, %rcx
jne 0x2f8f
jmp 0x2fbc
addl %edx, %edi
subl %r10d, %edi
movl %edi, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/mbf.c
// Function: get_index
int
get_index(Font *font, uint16_t code)
{
    int index;
    uint16_t *cur_code;
    uint16_t codes[] = {code, 0xFFFD, 0x003F, 0x0020, 0};

    for (cur_code = &codes[0]; *cur_code; cur_code++) {
        index = search_glyph(font, *cur_code);
        if (index != -1)
            break;
    };
    return index;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movabsq $0x20003ffffd, %rax     # imm = 0x20003FFFFD
movq %rax, 0x8(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %esi, %esi
je 0x3008
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movzwl %si, %esi
movq %r14, %rdi
callq 0x2f74
cmpl $-0x1, %eax
jne 0x3006
movzwl (%r15), %esi
addq $0x2, %r15
testw %si, %si
jne 0x2fe7
jmp 0x3008
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/gif.c
// Function: new_gif
GIF *
new_gif(const char *fname, uint16_t w, uint16_t h, uint8_t *gct, int loop)
{
    GIF *gif = calloc(1, sizeof(*gif) + 2*w*h);
    if (!gif)
        goto no_gif;
    gif->w = w; gif->h = h;
    gif->cur = (uint8_t *) &gif[1];
    gif->old = &gif->cur[w*h];
    /* fill back-buffer with invalid pixels to force overwrite */
    memset(gif->old, 0x10, w*h);
    gif->fd = creat(fname, 0666);
    if (gif->fd == -1)
        goto no_fd;
    write(gif->fd, "GIF89a", 6);
    write_num(gif->fd, w);
    write_num(gif->fd, h);
    write(gif->fd, (uint8_t []) {0xF3, 0x00, 0x00}, 3);
    write(gif->fd, gct, 0x30);
    if (loop >= 0 && loop <= 0xFFFF)
        put_loop(gif, (uint16_t) loop);
    return gif;
no_fd:
    free(gif);
no_gif:
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
movl %esi, %ebp
imull %edx, %ebp
leal 0x130(,%rbp,2), %esi
movl $0x1, %edi
callq 0x1110
testq %rax, %rax
je 0x3189
movq %rax, %rbx
movw %r12w, (%rax)
movw %r15w, 0x2(%rax)
addq $0x130, %rax            # imm = 0x130
movq %rax, 0x10(%rbx)
leaq 0x130(%rbx,%rbp), %rdi
movq %rdi, 0x18(%rbx)
movl $0x10, %esi
movq %rbp, %rdx
callq 0x10c0
movq %r13, %rdi
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x11e0
movl %eax, 0x4(%rbx)
cmpl $-0x1, %eax
je 0x3181
leaq 0x2957(%rip), %rsi      # 0x59f8
movl $0x6, %edx
movl %eax, %edi
callq 0x1080
movl 0x4(%rbx), %edi
leaq 0xc(%rsp), %rsi
movw %r12w, (%rsi)
movl $0x2, %edx
callq 0x1080
movl 0x4(%rbx), %edi
leaq 0xa(%rsp), %rsi
movw %r15w, (%rsi)
movl $0x2, %edx
callq 0x1080
movl 0x4(%rbx), %edi
leaq 0x12(%rsp), %rsi
movw $0xf3, (%rsi)
movb $0x0, 0x2(%rsi)
movl $0x3, %edx
callq 0x1080
movl 0x4(%rbx), %edi
movl $0x30, %edx
movq %r14, %rsi
callq 0x1080
movl 0x4(%rsp), %ebp
cmpl $0xffff, %ebp           # imm = 0xFFFF
ja 0x318b
movl 0x4(%rbx), %edi
leaq 0x15(%rsp), %rsi
movw $0xff21, (%rsi)         # imm = 0xFF21
movb $0xb, 0x2(%rsi)
movl $0x3, %edx
callq 0x1080
movl 0x4(%rbx), %edi
leaq 0x28cc(%rip), %rsi      # 0x5a01
movl $0xb, %edx
callq 0x1080
movl 0x4(%rbx), %edi
leaq 0x10(%rsp), %rsi
movw $0x103, (%rsi)          # imm = 0x103
movl $0x2, %edx
callq 0x1080
movl 0x4(%rbx), %edi
leaq 0xe(%rsp), %rsi
movw %bp, (%rsi)
movl $0x2, %edx
callq 0x1080
movl 0x4(%rbx), %edi
leaq 0x289e(%rip), %rsi      # 0x5a13
movl $0x1, %edx
callq 0x1080
jmp 0x318b
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/gif.c
// Function: new_trie
static Node *
new_trie(int *nkeys)
{
    Node *root = new_node(0);
    /* Create nodes for single pixels. */
    for (*nkeys = 0; *nkeys < 0x10; (*nkeys)++)
        root->children[*nkeys] = new_node(*nkeys);
    *nkeys += 2; /* skip clear code and stop code */
    return root;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x88, %esi
callq 0x1110
movq %rax, %r14
xorl %r15d, %r15d
movl $0x1, %edi
movl $0x88, %esi
callq 0x1110
testq %rax, %rax
je 0x3628
movw %r15w, (%rax)
movq %rax, 0x8(%r14,%r15,8)
incq %r15
cmpq $0x10, %r15
jne 0x3610
movl $0x12, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/gif.c
// Function: put_key
static void
put_key(GIF *gif, uint16_t key, int key_size)
{
    int byte_offset, bit_offset, bits_to_write;
    byte_offset = gif->offset / 8;
    bit_offset = gif->offset % 8;
    gif->partial |= ((uint32_t) key) << bit_offset;
    bits_to_write = bit_offset + key_size;
    while (bits_to_write >= 8) {
        gif->buffer[byte_offset++] = gif->partial & 0xFF;
        if (byte_offset == 0xFF) {
            write(gif->fd, "\xFF", 1);
            write(gif->fd, gif->buffer, 0xFF);
            byte_offset = 0;
        }
        gif->partial >>= 8;
        bits_to_write -= 8;
    }
    gif->offset = (gif->offset + key_size) % (0xFF * 8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %edi
leal 0x7(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %r8d
andl $-0x8, %r8d
movl %edi, %ecx
subl %r8d, %ecx
shll %cl, %esi
orl 0x28(%rbx), %esi
movl %edx, %r14d
movl %esi, 0x28(%rbx)
leal (%rcx,%r14), %edx
cmpl $0x8, %edx
jl 0x36d6
sarl $0x3, %eax
leaq 0x2d(%rbx), %r15
leal (%rcx,%r14), %ebp
addl $0x8, %ebp
leaq 0x2381(%rip), %r12      # 0x5a11
movslq %eax, %rcx
incl %eax
movb %sil, (%r15,%rcx)
cmpl $0xff, %eax
jne 0x36c2
movl 0x4(%rbx), %edi
movl $0x1, %edx
movq %r12, %rsi
callq 0x1080
movl 0x4(%rbx), %edi
movl $0xff, %edx
movq %r15, %rsi
callq 0x1080
xorl %eax, %eax
movl 0x28(%rbx), %esi
shrl $0x8, %esi
movl %esi, 0x28(%rbx)
addl $-0x8, %ebp
cmpl $0xf, %ebp
jg 0x3690
movl 0x8(%rbx), %edi
addl %r14d, %edi
movslq %edi, %rax
imulq $-0x7f7f7f7f, %rax, %rcx # imm = 0x80808081
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0xa, %ecx
addl %edx, %ecx
imull $0x7f8, %ecx, %ecx      # imm = 0x7F8
subl %ecx, %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/gif.c
// Function: del_trie
static void
del_trie(Node *root)
{
    int i;

    if (!root)
        return;
    for (i = 0; i < 0x10; i++)
        del_trie(root->children[i]);
    free(root);
}

// Assembly:
testq %rdi, %rdi
je 0x373a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x3707
incq %r14
cmpq $0x11, %r14
jne 0x3719
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lecram[P]congif/main.c
// Function: get_pair
uint8_t
get_pair(Term *term, int row, int col)
{
    Cell cell;
    uint8_t fore, back;
    int inverse;

    inverse = term->mode & M_REVERSE;
    if (term->mode & M_CURSORVIS)
        inverse = term->row == row && term->col == col ? !inverse : inverse;
    cell = term->addr[row][col];
    inverse = cell.attr & A_INVERSE ? !inverse : inverse;
    fore = cell.pair >> 4;
    back = cell.pair & 0xF;
    if (cell.attr & (A_ITALIC | A_CROSSED))
        fore = 0x2;
    else if (cell.attr & A_UNDERLINE)
        fore = 0x6;
    else if (cell.attr & A_DIM)
        fore = 0x8;
    if (inverse) {
        uint8_t t;
        t = fore; fore = back; back = t;
    }
    if (cell.attr & A_BOLD)
        fore |= 0x8;
    if (cell.attr & A_BLINK)
        back |= 0x8;
    if ((cell.attr & A_INVISIBLE) != 0) fore = back;
    return (fore << 4) | (back & 0xF);
}

// Assembly:
movzwl 0x18(%rdi), %ecx
movl %ecx, %eax
andl $0x20, %eax
btl $0xa, %ecx
jae 0x375b
cmpl %esi, 0x8(%rdi)
jne 0x375b
cmpl %edx, 0xc(%rdi)
jne 0x375b
shrl $0x5, %eax
xorl $0x1, %eax
movq 0x20(%rdi), %rcx
movslq %esi, %rsi
movq (%rcx,%rsi,8), %rsi
movslq %edx, %rdx
movzbl 0x2(%rsi,%rdx,4), %ecx
movb 0x3(%rsi,%rdx,4), %dl
movb $0x2, %sil
testb $-0x7c, %cl
jne 0x3797
movb $0x6, %sil
testb $0x8, %cl
jne 0x3797
movl %edx, %esi
shrb $0x4, %sil
testb $0x2, %cl
movzbl %sil, %edi
movl $0x8, %esi
cmovel %edi, %esi
andb $0xf, %dl
xorl %edi, %edi
testl %eax, %eax
sete %dil
testb $0x20, %cl
cmovel %eax, %edi
testl %edi, %edi
movzbl %sil, %eax
movzbl %dl, %edx
movl %eax, %esi
cmovel %edx, %esi
cmovel %eax, %edx
leal (,%rcx,8), %eax
orb %dl, %al
movl %ecx, %edx
shrb %dl
andb $0x8, %dl
orb %sil, %dl
testb $0x40, %cl
movzbl %al, %ecx
movzbl %dl, %eax
cmovnel %eax, %ecx
shlb $0x4, %cl
orb %cl, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %esi
callq 0x2fbe
cmpl $-0x1, %eax
je 0x38b9
movzbl 0x3(%r15), %edi
testl %edi, %edi
je 0x38b9
movl 0x8(%r15), %r8d
imull %r8d, %eax
imull %edi, %eax
cltq
addq 0x18(%r15), %rax
imull %edi, %ebp
movl %r12d, %esi
shrb $0x4, %sil
andb $0xf, %r12b
movb 0x2(%r15), %r9b
xorl %ecx, %ecx
movzbl %r12b, %edx
movzbl %sil, %esi
testb %r9b, %r9b
je 0x38a3
movzbl %r9b, %edi
imull %ebx, %edi
movslq %edi, %rdi
movslq %ebp, %r8
xorl %r10d, %r10d
movl %r10d, %r9d
shrl $0x3, %r9d
movzbl (%rax,%r9), %r9d
movl %r10d, %r11d
notb %r11b
movzbl %r11b, %r11d
andl $0x7, %r11d
btl %r11d, %r9d
movl %esi, %r9d
cmovael %edx, %r9d
movzwl (%r14), %r11d
imulq %r8, %r11
addq 0x10(%r14), %r11
addq %rdi, %r11
movb %r9b, (%r10,%r11)
movzbl 0x2(%r15), %r9d
incq %r10
cmpl %r9d, %r10d
jb 0x3854
movl 0x8(%r15), %r8d
movb 0x3(%r15), %dil
jmp 0x38a6
xorl %r9d, %r9d
incl %ebp
movslq %r8d, %r10
addq %r10, %rax
incl %ecx
movzbl %dil, %r10d
cmpl %r10d, %ecx
jb 0x383f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x3939
movq %rsi, %r15
movl 0x4(%r14), %eax
xorl %r12d, %r12d
testl %eax, %eax
jle 0x392e
xorl %r13d, %r13d
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rax
movzwl (%rax,%r13,4), %ebp
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x373c
movzbl %al, %ecx
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x37de
incq %r13
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jl 0x38ee
movl (%r14), %ecx
incq %r12
movslq %ecx, %rdx
cmpq %rdx, %r12
jl 0x38e7
xorl %eax, %eax
cmpb $0x0, 0x19c(%r14)
leaq 0x16c(%r14), %rcx
cmovneq %rcx, %rax
movq %rax, 0x20(%rbx)
movb 0x19d(%r14), %al
orb %al, 0x2c(%rbx)
movb $0x0, 0x19d(%r14)
movzwl 0x4(%rsp), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x319d
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testl %edi, %edi
movl $0xf0, %ebx
cmovnel %edi, %ebx
cmpq $0x0, 0x7fba(%rip)      # 0xb4b0
sete %al
testl %ebx, %ebx
setle %cl
orb %al, %cl
jne 0x3517
movq 0x7fa7(%rip), %rsi      # 0xb4b0
movl $0x80, %edi
callq 0x20e0
decl %ebx
jne 0x3502
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x0, 0x7e28(%rip)      # 0xb348
je 0x353e
cmpb $0x0, 0x7e24(%rip)      # 0xb34d
jne 0x353e
pushq %rax
movswl 0x7edd(%rip), %esi      # 0xb410
xorl %edi, %edi
callq 0x69eb
addq $0x8, %rsp
movb $0x0, 0x7e03(%rip)      # 0xb348
movw $0x0, 0x7ec2(%rip)      # 0xb410
retq
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: printPermanentSymbolTable
void printPermanentSymbolTable()
{
  int     ix;
  FILE   *permfile;
  char  *s_type;

  if(( permfile = fopen( permpathname, "w" )) == NULL )
  {
    exit( 2 );
  }

  fprintf( permfile, "/ PERMANENT SYMBOL TABLE\n/\n" );
  fprintf( permfile, "        EXPUNGE\n/\n" );
  /* Print the memory reference instructions first.                           */
  s_type = "FIXMRI";
  for( ix = 0; ix < symbol_top; ix++ )
  {
    if( M_MRI( symtab[ix].type ))
    {
      fprintf( permfile, "%-7s %s=%4.4o\n",
                                    s_type, symtab[ix].name, symtab[ix].val );
    }
  }

  s_type = " ";
  for( ix = 0; ix < symbol_top; ix++ )
  {
    if( M_FIXED( symtab[ix].type ))
    {
      if( !M_MRI( symtab[ix].type ) && !M_PSEUDO( symtab[ix].type ))
      {
        fprintf( permfile, "%-7s %s=%4.4o\n",
                                    s_type, symtab[ix].name, symtab[ix].val );
      }
    }
  }
  fprintf( permfile, "/\n        FIXTAB\n" );
  fclose( permfile );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x7e5f(%rip), %rdi      # 0xb560
leaq 0x3d02(%rip), %rsi      # 0x740a
callq 0x2160
testq %rax, %rax
je 0x3855
movq %rax, %rbx
leaq 0x425d(%rip), %rdi      # 0x797d
movl $0x1b, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x21a0
leaq 0x4260(%rip), %rdi      # 0x7999
movl $0x12, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x21a0
movl 0x7caf(%rip), %eax      # 0xb400
testl %eax, %eax
jle 0x382b
movq 0x7c98(%rip), %rcx      # 0xb3f8
leaq 0x424c(%rip), %r14      # 0x79b3
leaq 0x423e(%rip), %r15      # 0x79ac
xorl %r12d, %r12d
xorl %r13d, %r13d
movl (%rcx,%r12), %edx
notl %edx
testb $0x5, %dl
jne 0x37a8
addq %r12, %rcx
addq $0x4, %rcx
movswl 0x8(%rcx), %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2120
movq 0x7c56(%rip), %rcx      # 0xb3f8
movl 0x7c58(%rip), %eax      # 0xb400
incq %r13
movslq %eax, %rdx
addq $0x18, %r12
cmpq %rdx, %r13
jl 0x3774
testl %eax, %eax
jle 0x382b
movq 0x7c36(%rip), %rcx      # 0xb3f8
leaq 0x41ea(%rip), %r14      # 0x79b3
leaq 0x412d(%rip), %r15      # 0x78fd
xorl %r12d, %r12d
xorl %r13d, %r13d
movl (%rcx,%r12), %edx
movl %edx, %esi
notl %esi
testb $0x43, %sil
je 0x381c
movl %edx, %esi
andl $0x2, %esi
je 0x381c
andl $0x5, %edx
cmpl $0x5, %edx
je 0x381c
addq %r12, %rcx
addq $0x4, %rcx
movswl 0x8(%rcx), %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2120
movq 0x7be2(%rip), %rcx      # 0xb3f8
movl 0x7be4(%rip), %eax      # 0xb400
incq %r13
movslq %eax, %rdx
addq $0x18, %r12
cmpq %rdx, %r13
jl 0x37d6
leaq 0x4190(%rip), %rdi      # 0x79c2
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x21a0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2090
movl $0x2, %edi
callq 0x2190
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.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( isalnum( line[cc] ))
  {
    while( isalnum( line[cc] )) { cc++; }
  }
  else if( isend( line[cc] ))
  {
    /* End-of-Line, don't advance cc!                                         */
  }
  else
  {
    switch( line[cc] )
    {
    case '"':     /* Quoted letter                                            */
      if( cc + 2 < maxcc )
      {
        cc++;
        cc++;
      }
      else
      {
        errorMessage( &no_literal_value, lexstart );
        cc++;
      }
      break;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x9c21(%rip), %eax      # 0xd814
movl %eax, 0x9c2b(%rip)      # 0xd824
movl 0x9c1d(%rip), %eax      # 0xd81c
movl %eax, 0x9e1b(%rip)      # 0xda20
movslq 0x9c20(%rip), %rbx      # 0xd82c
leaq 0x9b7d(%rip), %r14      # 0xd790
movq %rbx, %rax
addq %r14, %rax
movabsq $0x4000000100001200, %rcx # imm = 0x4000000100001200
movzbl (%rax), %edx
cmpq $0x3e, %rdx
ja 0x3c3f
btq %rdx, %rcx
jae 0x3c3f
incl %ebx
movl %ebx, 0x9bf2(%rip)      # 0xd82c
incq %rax
jmp 0x3c23
movsbq %dl, %r15
movl %ebx, 0x9bcb(%rip)      # 0xd814
callq 0x21c0
movq (%rax), %rcx
testb $0x8, (%rcx,%r15,2)
jne 0x3c6c
movzbl %r15b, %eax
cmpl $0x21, %eax
jg 0x3c94
testl %eax, %eax
je 0x3ccd
cmpl $0xa, %eax
je 0x3ccd
jmp 0x3cc1
movslq %ebx, %rax
movsbq (%rax,%r14), %rdx
testb $0x8, (%rcx,%rdx,2)
je 0x3ccd
leaq (%rax,%r14), %rdx
incq %rdx
movl %ebx, %eax
movsbq (%rdx), %rsi
incl %eax
incq %rdx
testb $0x8, (%rcx,%rsi,2)
jne 0x3c83
jmp 0x3cc5
cmpl $0x2f, %eax
je 0x3ccd
cmpl $0x22, %eax
jne 0x3cc1
leal 0x2(%rbx), %eax
cmpl 0x9b89(%rip), %eax      # 0xd830
jl 0x3cc5
leaq 0x75e8(%rip), %rdi      # 0xb298
movl %ebx, %esi
callq 0x5ac8
movl 0x9b6f(%rip), %eax      # 0xd82c
incl %eax
jmp 0x3cc5
incl %ebx
movl %ebx, %eax
movl %eax, 0x9b61(%rip)      # 0xd82c
movl %eax, %ebx
movl %ebx, 0x9b49(%rip)      # 0xd81c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
leaq 0x797d(%rip), %rdi      # 0xb660
movl $0x1, %esi
callq 0x3fe1
cmpb $0x0, 0x9b24(%rip)      # 0xd818
je 0x3d4d
movb $0x1, 0x9a6b(%rip)      # 0xd768
movzwl 0x9a5c(%rip), %eax      # 0xd760
movl $0x7000, %ebx           # imm = 0x7000
movl %eax, %ecx
andl %ebx, %ecx
decl %eax
movl $0xfff, %ebp            # imm = 0xFFF
andl %ebp, %eax
orl %ecx, %eax
movw %ax, 0x9a41(%rip)       # 0xd760
leaq 0x7532(%rip), %rdi      # 0xb258
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5ac8
movzwl 0x9a29(%rip), %eax      # 0xd760
andl %eax, %ebx
incl %eax
andl %ebp, %eax
orl %ebx, %eax
movw %ax, 0x9a1a(%rip)       # 0xd760
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6789
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: punchLiteralPool
void punchLiteralPool( LPOOL_T *p, BOOL punch_page0 )
{
  WORD16  loc;
  WORD16  tmplc;
  int lpool_page = 0; /* Silence false uninitialized error from GCC */
  int i;

  for (i = MAX_PAGES-1; i >= 0;  i--) {
    lpool_page = (i << 7) & 07600;

    if ( p[i].loc != p[i].last_punched && (punch_page0 || lpool_page != 0) )
    {
      if( !rim_mode )
      {
        /* Put out origin if not in rim mode.                                 */
        punchOrigin( p[i].loc | lpool_page );
      }
      /* Put the literals in the object file.                                 */
      for( loc = p[i].loc; loc < p[i].last_punched; loc++ )
      {
        tmplc = loc + lpool_page;
        printLine( line, (field | tmplc), p[i].pool[loc], LOC_VAL );
        punchLocObject( tmplc, p[i].pool[loc] );
      }
      p[i].last_punched = p[i].loc;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r15
leaq 0x1f80(%rdi), %r12
movl $0x1f, %r13d
movl $0xf80, %esi            # imm = 0xF80
movl %ebx, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
testb %bl, %bl
setne %cl
movl %r13d, %edi
shll $0x7, %edi
movq %r13, %rax
shlq $0x8, %rax
leaq (%rax,%r13,4), %r14
movzwl (%r15,%r14), %ebp
movzwl 0x2(%r15,%r14), %eax
testl $0xf80, %edi            # imm = 0xF80
setne %dl
cmpw %ax, %bp
je 0x40f6
orb %dl, %cl
je 0x40f6
addq %r15, %r14
cmpb $0x0, 0x72f9(%rip)      # 0xb34d
jne 0x4081
orl %ebp, %edi
shrl $0x6, %edi
andl $0x3f, %edi
orl $0x40, %edi
movl %esi, 0x8(%rsp)
callq 0x6a30
andl $0x3f, %ebp
movl %ebp, %edi
callq 0x6a30
movl 0x8(%rsp), %esi
movzwl (%r14), %ebp
movzwl 0x2(%r14), %eax
cmpw %ax, %bp
jge 0x40f1
movl %esi, 0x8(%rsp)
movl %esi, %r15d
andl $0xff80, %r15d          # imm = 0xFF80
movswq %bp, %rbx
addl %ebp, %r15d
leaq 0x96ee(%rip), %rbp      # 0xd790
movzwl 0x96b9(%rip), %eax      # 0xd762
orw %r15w, %ax
movswl (%r12,%rbx,2), %edx
movswl %ax, %esi
movq %rbp, %rdi
movl $0x3, %ecx
callq 0x4119
movswl (%r12,%rbx,2), %esi
movswl %r15w, %edi
callq 0x69eb
incq %rbx
movswq 0x2(%r14), %rax
incl %r15d
cmpq %rax, %rbx
jl 0x40a2
movzwl (%r14), %ebp
movl 0xc(%rsp), %ebx
movq 0x10(%rsp), %r15
movl 0x8(%rsp), %esi
movw %bp, 0x2(%r14)
addq $-0x104, %r12           # imm = 0xFEFC
addl $-0x80, %esi
subq $0x1, %r13
jae 0x400f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: printLine
void printLine( char *line, WORD16 loc, WORD16 val, LINESTYLE_T linestyle )
{
  char rlc;

  if( listfile == NULL )
  {
    save_error_count = 0;
    return;
  }

  printPageBreak();

  list_lineno++;
  page_lineno++;

  if (reloc == 0)
  {
    rlc = ' ';
  }
  else
  {
    rlc = '*';
  }

  switch( linestyle )
  {
  default:
  case LINE:
    fprintf(listfile, "%5d              ", lineno );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_VAL:
    fprintf(listfile, "%5d        %4.4o  ", lineno, val );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_LOC_VAL:
    if( !listed )
    {
      if( indirect_generated )
      {
        fprintf( listfile, "%5d %5.5o%c %4.4o@ ", lineno, loc, rlc, val );
      }
      else
      {
        fprintf( listfile, "%5d %5.5o%c %4.4o  ", lineno, loc, rlc, val );
      }
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.5o%c %4.4o\n", loc, rlc, val );
    }
    break;

  case LOC_VAL:
    fprintf( listfile, "      %5.5o%c %4.4o\n", loc, rlc, val );
    break;
  }
  printErrorMessages();
}

// Assembly:
cmpq $0x0, 0x741f(%rip)      # 0xb540
je 0x418d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x67af
incl 0x9634(%rip)            # 0xd774
incl 0x72ce(%rip)            # 0xb414
cmpw $0x0, 0x9618(%rip)      # 0xd766
movl $0x20, %ecx
movl $0x2a, %eax
cmovel %ecx, %eax
cmpl $0x1, %r15d
je 0x41c2
cmpl $0x2, %r15d
je 0x4198
cmpl $0x3, %r15d
je 0x41a1
movq 0x73cc(%rip), %rdi      # 0xb540
movl 0x95f2(%rip), %edx      # 0xd76c
leaq 0x376c(%rip), %rsi      # 0x78ed
xorl %eax, %eax
callq 0x2120
jmp 0x421a
movl $0x0, 0x7255(%rip)      # 0xb3ec
retq
cmpb $0x0, 0x95c9(%rip)      # 0xd768
je 0x41e2
movq 0x7398(%rip), %rdi      # 0xb540
movswl %r14w, %edx
movswl %bp, %r8d
leaq 0x3783(%rip), %rsi      # 0x793a
movl %eax, %ecx
xorl %eax, %eax
callq 0x2120
jmp 0x4230
movq 0x7377(%rip), %rdi      # 0xb540
movl 0x959d(%rip), %edx      # 0xd76c
movswl %bp, %ecx
leaq 0x3726(%rip), %rsi      # 0x78ff
xorl %eax, %eax
callq 0x2120
jmp 0x421a
cmpb $0x0, 0x963f(%rip)      # 0xd828
movq 0x7350(%rip), %rdi      # 0xb540
movl 0x9576(%rip), %edx      # 0xd76c
movswl %r14w, %ecx
movswl %bp, %r9d
leaq 0x3721(%rip), %r8       # 0x7926
leaq 0x3706(%rip), %rsi      # 0x7912
cmoveq %r8, %rsi
movl %eax, %r8d
xorl %eax, %eax
callq 0x2120
movq 0x731f(%rip), %rsi      # 0xb540
movq %rbx, %rdi
callq 0x20c0
movb $0x1, 0x9538(%rip)      # 0xd768
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x68f4
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: lookup
SYM_T *lookup( char *name )
{
  int     ix;                   /* Insertion index                            */
  int     lx;                   /* Left index                                 */
  int     rx;                   /* Right index                                */

  /* First search the permanent symbols.                                      */
  lx = 0;
  ix = binarySearch( name, lx, number_of_fixed_symbols );

  /* If symbol not in permanent symbol table.                                 */
  if( ix < 0 )
  {
    /* Now try the user symbol table.                                         */
    ix = binarySearch( name, number_of_fixed_symbols, symbol_top );

    /* If symbol not in user symbol table.                                    */
    if( ix < 0 )
    {
      /* Must put symbol in table if index is negative.                       */
      ix = ~ix;
      if( symbol_top + 1 >= SYMBOL_TABLE_SIZE )
      {
        errorSymbol( &symbol_table_full, name, lexstart );
        exit( 1 );
      }

      for( rx = symbol_top; rx >= ix; rx-- )
      {
        symtab[rx + 1] = symtab[rx];
      }
      symbol_top++;

      /* Enter the symbol as UNDEFINED with a value of zero.                  */
      strcpy( symtab[ix].name, name );
      symtab[ix].type = UNDEFINED;
      symtab[ix].val  = 0;
      symtab[ix].xref_count = 0;
      if( xref && pass == 2 )
      {
        xreftab[symtab[ix].xref_index] = 0;
      }
    }
  }

  return( &symtab[ix] );        /* Return the location of the symbol.         */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x71b4(%rip), %ebp      # 0xb404
xorl %esi, %esi
movl %ebp, %edx
callq 0x6a58
testl %eax, %eax
js 0x4264
movl %eax, %ebx
jmp 0x432f
movl 0x7195(%rip), %r15d     # 0xb400
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x6a58
movl %eax, %ebx
testl %eax, %eax
jns 0x432f
cmpl $0xffe, %r15d           # imm = 0xFFE
jg 0x4349
notl %ebx
movq 0x7160(%rip), %rax      # 0xb3f8
movl %ebx, %r12d
cmpl %ebx, %r15d
jl 0x42c7
leaq 0x1(%r15), %rcx
leaq (%r15,%r15,2), %rdx
leaq (%rax,%rdx,8), %rdx
movq 0x10(%rdx), %rsi
movq %rsi, 0x28(%rdx)
movups (%rdx), %xmm0
movups %xmm0, 0x18(%rdx)
decq %rcx
addq $-0x18, %rdx
cmpq %r12, %rcx
jg 0x42ac
incl %r15d
movl %r15d, 0x712f(%rip)     # 0xb400
leaq (,%r12,8), %rcx
leaq (%rcx,%rcx,2), %r15
leaq (%rax,%r15), %rdi
addq $0x4, %rdi
movq %r14, %rsi
callq 0x2070
movq 0x7104(%rip), %rax      # 0xb3f8
xorl %ecx, %ecx
movl %ecx, (%rax,%r15)
movw $0x0, 0xc(%rax,%r15)
movl %ecx, 0x14(%rax,%r15)
cmpb $0x0, 0x7043(%rip)      # 0xb351
je 0x432f
cmpl $0x2, 0x70d9(%rip)      # 0xb3f0
jne 0x432f
movq 0x7230(%rip), %rcx      # 0xb550
leaq (%r12,%r12,2), %rdx
movslq 0x10(%rax,%rdx,8), %rax
movw $0x0, (%rcx,%rax,2)
movl %ebx, %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x70b8(%rip), %rax      # 0xb3f8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x94c5(%rip), %edx      # 0xd814
leaq 0x6f82(%rip), %rdi      # 0xb2d8
movq %r14, %rsi
callq 0x43d8
movl $0x1, %edi
callq 0x2190
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl %edx, %esi
jge 0x43bd
movl %edx, %ebp
movl %esi, %r14d
callq 0x2030
movslq %r14d, %rdx
movslq %ebp, %rsi
leaq 0x1(%rdx), %rdi
xorl %r8d, %r8d
leaq 0x93fd(%rip), %r9       # 0xd790
movq (%rax), %rcx
leaq (%rdi,%r8), %r10
leaq (%rdx,%r8), %r11
movsbq (%r9,%r11), %r11
movb (%rcx,%r11,4), %r11b
leaq 0x1(%r8), %rcx
movb %r11b, (%rbx,%r8)
cmpq %rsi, %r10
jge 0x43bd
cmpq $0x5, %r8
movq %rcx, %r8
jb 0x4393
movl %ecx, %edi
addq %rbx, %rdi
movl $0x7, %edx
subl %ecx, %edx
xorl %esi, %esi
callq 0x20d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x2, 0x7011(%rip)      # 0xb3f0
jne 0x446d
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x32e7(%rip), %r15      # 0x76e6
cmovneq %rsi, %r15
incl 0x6fdf(%rip)            # 0xb3e8
movl 0x935d(%rip), %edx      # 0xd76c
leal 0x1(%rbx), %ecx
leaq 0x361a(%rip), %rsi      # 0x7a33
leaq 0xc(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x2180
movq 0x6fb1(%rip), %rdi      # 0xb3e0
movq 0x8(%r14), %r8
movswl 0x9326(%rip), %eax      # 0xd760
movl %eax, (%rsp)
leaq 0x35f7(%rip), %rsi      # 0x7a3b
leaq 0x7195(%rip), %rdx      # 0xb5e0
movq %r12, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movl %ebx, %esi
callq 0x6b7f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movb $0x1, 0x93a4(%rip)      # 0xd818
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
callq 0x3be8
movzbl 0x9325(%rip), %eax      # 0xd820
cmpq $0x3e, %rax
ja 0x4525
movabsq $0x4000000100001200, %rcx # imm = 0x4000000100001200
btq %rax, %rcx
jae 0x4525
movl 0x92fd(%rip), %esi      # 0xd814
decl %esi
leaq 0x6c08(%rip), %rdi      # 0xb128
callq 0x5ac8
movslq 0x92f0(%rip), %rax      # 0xd81c
leaq 0x925d(%rip), %rcx      # 0xd790
movb (%rax,%rcx), %al
movb %al, 0x92e4(%rip)       # 0xd820
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movl 0x91d1(%rip), %esi      # 0xd814
movl 0x91d3(%rip), %edx      # 0xd81c
leaq 0x9(%rsp), %rbx
movq %rbx, %rdi
callq 0x4368
movq %rbx, %rdi
callq 0x423f
movl 0x91b0(%rip), %esi      # 0xd814
movl 0x9102(%rip), %ecx      # 0xd76c
cmpl 0x9108(%rip), %esi      # 0xd778
jne 0x467a
cmpl 0x9104(%rip), %ecx      # 0xd77c
je 0x46b4
movslq 0x14(%rax), %rdx
incq %rdx
movl %edx, 0x14(%rax)
movl %esi, 0x90ee(%rip)      # 0xd778
movl %ecx, 0x90ec(%rip)      # 0xd77c
cmpb $0x0, 0x6cba(%rip)      # 0xb351
je 0x46b4
cmpl $0x2, 0x6d50(%rip)      # 0xb3f0
jne 0x46b4
movq 0x6ea7(%rip), %rsi      # 0xb550
movslq 0x10(%rax), %rdi
addq %rdx, %rdi
movw %cx, (%rsi,%rdi,2)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movswl 0x80ec(%rip), %edi      # 0xd760
callq 0x672b
movzwl 0x80e0(%rip), %eax      # 0xd760
movl %eax, %ecx
andl $0x7000, %ecx           # imm = 0x7000
incl %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x80ce(%rip)       # 0xd764
orl %ecx, %eax
movw %ax, 0x80c1(%rip)       # 0xd760
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/palbart/palbart.c
// Function: fixMRIInstruction
WORD16 fixMRIInstruction(WORD16 instruction, WORD16 value)
{
        /* Now have the address part of the MRI instruction.                  */
        if( value < 00200 )
        {
          instruction |= value;        /* Page zero MRI.                             */
        }
        else if( (( fieldlc + reloc ) & 07600 ) <= value
             && value <= ((( fieldlc + reloc ) & 07600) | 0177 ))
        {
          instruction |= ( PAGE_BIT | (value & ADDRESS_FIELD )); /* Current page MRI */
        }
        else
        {
          if(( instruction & INDIRECT_BIT ) == INDIRECT_BIT )
          {
            /* Already indirect, can't generate                               */
            errorSymbol( &illegal_indirect, NULL, lexstartprev );
          }
          else
          {
            if( literals_ok )
            {
              /* Now fix off page reference.                                  */
              /* Search current page literal pool for needed instruction.           */
              /* Set Indirect Current Page                                    */
              instruction |= ( 00600 | insertLiteral( cp, value, GET_PAGE_INDEX(clc) ));
              indirect_generated = TRUE;
              if (pass == 2)
              {
                links++;
              }
            }
            else
            {
              errorSymbol( &illegal_reference, NULL, lexstartprev );
              instruction |= ( value & 0177 );
            }
          }
        }
   return instruction;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
cmpw $0x7f, %bp
jg 0x56b7
orl %ebx, %ebp
movl %ebp, %ebx
jmp 0x5769
movzwl %bp, %eax
movzwl 0x80a3(%rip), %ecx      # 0xd764
movzwl 0x809e(%rip), %edx      # 0xd766
addl %ecx, %edx
andl $0xf80, %edx            # imm = 0xF80
cmpl %eax, %edx
seta %cl
orl $0x7f, %edx
cmpl %eax, %edx
setb %al
orb %cl, %al
je 0x572c
btl $0x8, %ebx
jb 0x573a
cmpb $0x0, 0x5c5c(%rip)      # 0xb34a
je 0x5750
movzwl 0x8069(%rip), %edx      # 0xd760
shrl $0x7, %edx
andl $0x1f, %edx
movswl %bp, %esi
leaq 0x5f59(%rip), %rdi      # 0xb660
callq 0x5772
orl %eax, %ebx
orl $0x180, %ebx            # imm = 0x180
movb $0x1, 0x810d(%rip)      # 0xd828
cmpl $0x2, 0x5cce(%rip)      # 0xb3f0
jne 0x5769
incl 0x5e2e(%rip)            # 0xb558
jmp 0x5769
movzbl %bpl, %eax
orl %eax, %ebx
orl $0x80, %ebx
jmp 0x5769
movl 0x80e4(%rip), %edx      # 0xd824
leaq 0x5a61(%rip), %rdi      # 0xb1a8
xorl %esi, %esi
callq 0x43d8
jmp 0x5769
movl 0x80ce(%rip), %edx      # 0xd824
leaq 0x5a5b(%rip), %rdi      # 0xb1b8
xorl %esi, %esi
callq 0x43d8
andl $0x7f, %ebp
orl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movslq %edx, %rax
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,4), %r8
leaq (%rdi,%r8), %rcx
movswq (%rdi,%r8), %rdi
cmpq $0x7f, %rdi
jg 0x57a7
movw $0x7f, %bx
movswq %bx, %r8
cmpw %si, 0x4(%rcx,%r8,2)
je 0x57e2
decl %ebx
cmpw %di, %bx
jge 0x5794
leaq -0x1(%rdi), %r8
movw %r8w, (%rcx)
movw %si, 0x2(%rcx,%rdi,2)
movswl (%rcx), %ebx
leaq 0x7f22(%rip), %rcx      # 0xd6e0
cmpl %ebx, (%rcx,%rax,4)
jl 0x57e2
testb $0xf, %dl
leaq 0x5a3b(%rip), %rax      # 0xb208
leaq 0x5a24(%rip), %rdi      # 0xb1f8
cmoveq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5ac8
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x2, 0x5921(%rip)      # 0xb3f0
jne 0x5b42
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
incl 0x5903(%rip)            # 0xb3e8
movl 0x7c81(%rip), %edx      # 0xd76c
leal 0x1(%rbx), %ecx
leaq 0x1f3e(%rip), %rsi      # 0x7a33
leaq 0x4(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2180
movq 0x58d5(%rip), %rdi      # 0xb3e0
movq 0x8(%r14), %r8
movswl 0x7c49(%rip), %r9d      # 0xd760
leaq 0x1f46(%rip), %rsi      # 0x7a64
leaq 0x5abb(%rip), %rdx      # 0xb5e0
movq %r15, %rcx
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movl %ebx, %esi
callq 0x6b7f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x7ccf(%rip)      # 0xd818
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x7cdb(%rip), %rax      # 0xd82c
leaq 0x7c38(%rip), %rcx      # 0xd790
addq %rax, %rcx
movzbl (%rcx), %edx
testl %edx, %edx
je 0x5b74
cmpl $0xa, %edx
je 0x5b74
incl %eax
movl %eax, 0x7cbd(%rip)      # 0xd82c
incq %rcx
jmp 0x5b5b
movl %eax, 0x7c9a(%rip)      # 0xd814
movl %eax, 0x7c9c(%rip)      # 0xd81c
movl %eax, 0x7c9e(%rip)      # 0xd824
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movb $0x0, 0x78d2(%rip)      # 0xd834
movslq 0x78b3(%rip), %r14      # 0xd81c
leaq 0x7820(%rip), %r12      # 0xd790
movb (%r14,%r12), %al
movb %al, 0x78a6(%rip)       # 0xd820
movslq 0x7893(%rip), %rbx      # 0xd814
cmpl %r14d, %ebx
jge 0x5fbf
callq 0x21c0
movq (%rax), %rdx
movsbq (%rbx,%r12), %rcx
testb $0x8, 0x1(%rdx,%rcx,2)
je 0x5fc4
leaq (%r15,%r15,4), %rdx
leaq (%rcx,%rdx,2), %rcx
addq $-0x30, %rcx
cmpq %r15, %rcx
jge 0x5fb2
movb $0x1, 0x7882(%rip)      # 0xd834
incq %rbx
movq %rcx, %r15
cmpl %r14d, %ebx
jl 0x5f8b
jmp 0x5fed
movq %r15, %rcx
jmp 0x5fed
movl 0x784a(%rip), %esi      # 0xd814
leaq 0x1(%rsp), %r15
movq %r15, %rdi
movl %r14d, %edx
callq 0x4368
leaq 0x5187(%rip), %rdi      # 0xb168
movq %r15, %rsi
movl %ebx, %edx
callq 0x43d8
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x37, 0x4c5e(%rip)     # 0xb414
jl 0x680c
cmpb $0x0, 0x6fc1(%rip)      # 0xd780
jne 0x67fe
pushq %rbx
leaq 0x7087(%rip), %rbx      # 0xd850
movq %rbx, %rdi
callq 0x20a0
cmpb $0xa, -0x1(%rax,%rbx)
jne 0x67dd
movb $0x0, -0x1(%rax,%rbx)
leaq 0x706c(%rip), %rdi      # 0xd850
callq 0x20a0
cmpq $0x40, %rax
popq %rbx
jb 0x67f7
movb $0x0, 0x7098(%rip)      # 0xd88f
movb $0x1, 0x6f82(%rip)      # 0xd780
leaq 0x704b(%rip), %rdi      # 0xd850
xorl %esi, %esi
jmp 0x680d
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x6f4b(%rip), %ebp      # 0xd770
incl %ebp
movl %ebp, 0x6f43(%rip)      # 0xd770
leaq 0x489d(%rip), %r15      # 0xb0d1
leaq 0x6(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2070
leaq 0x11c2(%rip), %rsi      # 0x7a0d
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2180
cmpl $0x2, 0x6f0f(%rip)      # 0xd770
jl 0x6874
movq 0x4cd6(%rip), %rsi      # 0xb540
movl $0xc, %edi
callq 0x20e0
movq 0x4cc5(%rip), %rdi      # 0xb540
leaq 0x1191(%rip), %rsi      # 0x7a13
leaq 0x6(%rsp), %rcx
movq %r14, %rdx
xorl %eax, %eax
callq 0x2120
movl $0x3, 0x4b79(%rip)      # 0xb414
movq 0x4c9e(%rip), %rax      # 0xb540
testq %rbx, %rbx
je 0x68bd
leaq 0x117a(%rip), %rsi      # 0x7a28
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
jmp 0x68ca
movl $0xa, %edi
movq %rax, %rsi
callq 0x20e0
incl 0x4b44(%rip)            # 0xb414
movq 0x4c69(%rip), %rsi      # 0xb540
movl $0xa, %edi
callq 0x20e0
incl 0x4b2d(%rip)            # 0xb414
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq