LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: symflags
char           *symflags(
    SYMBOL *sym)
{
    static char     temp[8];
    char           *fp = temp;

    if (sym->flags & SYMBOLFLAG_GLOBAL)
        *fp++ = 'G';
    if (sym->flags & SYMBOLFLAG_PERMANENT)
        *fp++ = 'P';
    if (sym->flags & SYMBOLFLAG_DEFINITION)
        *fp++ = 'D';
    *fp = 0;
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0xd7b5(%rip), %rax      # 0x1b6a4
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xdf14
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x47, (%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdf35
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x50, (%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xdf56
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x44, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: free_sym
void free_sym(
    SYMBOL *sym)
{
    if (sym->label) {
        free(sym->label);
        sym->label = NULL;
    }
    free(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdf9d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: remove_sym
void remove_sym(
    SYMBOL *sym,
    SYMBOL_TABLE *table)
{
    SYMBOL        **prevp,
                   *symp;
    int             hash;

    hash = hash_name(sym->label);
    prevp = &table->hash[hash];
    while (symp = *prevp, symp != NULL && symp != sym)
        prevp = &symp->next;

    if (symp)
        *prevp = sym->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xde90
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x25(%rbp)
je 0xe007
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xe010
jmp 0xe01e
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0xdfe2
cmpq $0x0, -0x20(%rbp)
je 0xe034
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: lookup_sym
SYMBOL         *lookup_sym(
    char *label,
    SYMBOL_TABLE *table)
{
    unsigned        hash;
    SYMBOL         *sym;

    hash = hash_name(label);

    sym = table->hash[hash];
    while (sym && strcmp(sym->label, label) != 0)
        sym = sym->next;

    return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xde90
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0xe090
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x21b0
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xe099
jmp 0xe0a7
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe06b
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: next_sym
SYMBOL         *next_sym(
    SYMBOL_TABLE *table,
    SYMBOL_ITER *iter)
{
    if (iter->current)
        iter->current = iter->current->next;

    while (iter->current == NULL) {
        if (iter->subscript >= HASH_SIZE)
            return NULL;               /* No more symbols. */
        iter->current = table->hash[iter->subscript];
        iter->subscript++;
    }

    return iter->current;              /* Got a symbol. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe0eb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe0ed
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe132
movq -0x18(%rbp), %rax
cmpl $0x3ff, (%rax)          # imm = 0x3FF
jl 0xe10e
movq $0x0, -0x8(%rbp)
jmp 0xe13e
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xe0ed
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: new_sym
static SYMBOL  *new_sym(
    char *label)
{
    SYMBOL         *sym = memcheck(malloc(sizeof(SYMBOL)));

    sym->label = memcheck(strdup(label));
    sym->section = NULL;
    sym->value = 0;
    sym->flags = 0;
    return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x136a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: sym_hist
void sym_hist(
    SYMBOL_TABLE *st,
    char *name)
{
    int             i;
    SYMBOL         *sym;

    fprintf(lstfile, "Histogram for symbol table %s\n", name);
    for (i = 0; i < 1023; i++) {
        fprintf(lstfile, "%4d: ", i);
        for (sym = st->hash[i]; sym != NULL; sym = sym->next)
            fputc('#', lstfile);
        fputc('\n', lstfile);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xb519(%rip), %rax      # 0x1b680
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5a1d(%rip), %rsi      # 0x15b92
movb $0x0, %al
callq 0x21c0
movl $0x0, -0x14(%rbp)
cmpl $0x3ff, -0x14(%rbp)     # imm = 0x3FF
jge 0x101ff
leaq 0xb4ed(%rip), %rax      # 0x1b680
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x5a11(%rip), %rsi      # 0x15bb1
movb $0x0, %al
callq 0x21c0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x101e0
leaq 0xb4bb(%rip), %rax      # 0x1b680
movq (%rax), %rsi
movl $0x23, %edi
callq 0x2150
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x101b7
leaq 0xb499(%rip), %rax      # 0x1b680
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2150
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10183
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: list_section
void list_section(
    SECTION *sec)
{
    if (sec == NULL) {
        fprintf(lstfile, "(null)\n");
        return;
    }

    int flags = sec->flags;

    fprintf(lstfile, "%-6s  %06o    %03d   ",
        sec->label, sec->size & 0177777, sec->sector);
    fprintf(lstfile, "(%s,%s,%s,%s,%s,%s)\n",
        (flags & PSECT_RO)   ? "RO"  : "RW",
        (flags & PSECT_DATA) ? "D"   : "I",
        (flags & PSECT_GBL)  ? "GBL" : "LCL",
        (flags & PSECT_REL)  ? "REL" : "ABS",
        (flags & PSECT_COM)  ? "OVR" : "CON",
        (flags & PSECT_SAV)  ? "SAV" : "NOSAV");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10690
leaq 0xb006(%rip), %rax      # 0x1b680
movq (%rax), %rdi
leaq 0x557d(%rip), %rsi      # 0x15c01
movb $0x0, %al
callq 0x21c0
jmp 0x10797
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0xafdf(%rip), %rax      # 0x1b680
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movq -0x8(%rbp), %rax
movl 0x18(%rax), %r8d
leaq 0x5542(%rip), %rsi      # 0x15c09
movb $0x0, %al
callq 0x21c0
leaq 0xafab(%rip), %rax      # 0x1b680
movq (%rax), %rdi
movl -0xc(%rbp), %ecx
andl $0x10, %ecx
leaq 0x4875(%rip), %rdx      # 0x14f5a
leaq 0x5200(%rip), %rax      # 0x158ec
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl -0xc(%rbp), %esi
andl $0x80, %esi
leaq 0x5450(%rip), %rcx      # 0x15b53
leaq 0x5477(%rip), %rax      # 0x15b81
cmpl $0x0, %esi
cmovneq %rax, %rcx
movl -0xc(%rbp), %esi
andl $0x40, %esi
leaq 0x483f(%rip), %r8       # 0x14f5d
leaq 0x4301(%rip), %rax      # 0x14a26
cmpl $0x0, %esi
cmovneq %rax, %r8
movl -0xc(%rbp), %esi
andl $0x20, %esi
leaq 0x480b(%rip), %r9       # 0x14f44
leaq 0x4808(%rip), %rax      # 0x14f48
cmpl $0x0, %esi
cmovneq %rax, %r9
movl -0xc(%rbp), %esi
andl $0x4, %esi
leaq 0x4802(%rip), %r10      # 0x14f56
leaq 0x47f7(%rip), %rax      # 0x14f52
cmpl $0x0, %esi
cmovneq %rax, %r10
movl -0xc(%rbp), %r11d
andl $0x1, %r11d
leaq 0x47db(%rip), %rax      # 0x14f4c
leaq 0x47d6(%rip), %rsi      # 0x14f4e
cmpl $0x0, %r11d
cmovneq %rsi, %rax
leaq 0x5498(%rip), %rsi      # 0x15c1f
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x21c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/mlb-rsx.c
// Function: mlb_close
void mlb_close(
    MLB *mlb)
{
    if (mlb) {
        int             i;

        if (mlb->directory) {
            for (i = 0; i < mlb->nentries; i++)
                if (mlb->directory[i].label)
                    free(mlb->directory[i].label);
            free(mlb->directory);
        }
        if (mlb->fp)
            fclose(mlb->fp);

        free(mlb);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10dd2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10db3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x10da6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x10d99
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2040
jmp 0x10d9b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10d59
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10dc9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x20b0
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/mlb-rsx.c
// Function: mlb_extract
void mlb_extract(
    MLB *mlb)
{
    int             i;
    FILE           *fp;
    BUFFER         *buf;

    for (i = 0; i < mlb->nentries; i++) {
        char            name[32];

        buf = mlb_entry(mlb, mlb->directory[i].label);
        if (buf != NULL) {
            char *suffix = mlb->is_objlib ? "OBJ" : "MAC";
            sprintf(name, "%s.%s", mlb->directory[i].label, suffix);
            fp = fopen(name, "w");
            int length = buf->length;
            fwrite(buf->buffer, 1, length, fp);
            fclose(fp);
            buffer_free(buf);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x112a6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x10e50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11296
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x3c90(%rip), %rax      # 0x14e9f
leaq 0x4ade(%rip), %rcx      # 0x15cf4
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x48(%rbp), %rcx
leaq 0x4ab2(%rip), %rsi      # 0x15cf8
movb $0x0, %al
callq 0x22a0
leaq -0x40(%rbp), %rdi
leaq 0x2f47(%rip), %rsi      # 0x1419f
callq 0x2260
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movslq -0x4c(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x22c0
movq -0x18(%rbp), %rdi
callq 0x20b0
movq -0x20(%rbp), %rdi
callq 0x12c20
jmp 0x11298
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x111c3
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: gsd_init
void gsd_init(
    GSD * gsd,
    FILE *fp)
{
    gsd->fp = fp;
    gsd->buf[0] = OBJ_GSD;             /* GSD records start with 1,0 */
    gsd->buf[1] = 0;
    gsd->offset = 2;                   /* Offset for further additions */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x9(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x84(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: gsd_flush
int gsd_flush(
    GSD * gsd)
{
    if (gsd->offset > 2) {
        if (!writerec(gsd->fp, gsd->buf, gsd->offset))
            return 0;
        gsd_init(gsd, gsd->fp);
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x84(%rax)
jle 0x11345
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edx
callq 0x11360
cmpl $0x0, %eax
jne 0x11335
movl $0x0, -0x4(%rbp)
jmp 0x1134c
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x112b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: writerec
static int writerec(
    FILE *fp,
    char *data,
    int len)
{
    int             chksum;     /* Checksum is negative sum of all
                                   bytes including header and length */
    int             i;
#if RT11
    unsigned        hdrlen = len + 4;
#else
    unsigned        hdrlen = len;
#endif

    if (fp == NULL)
        return 1;                      /* Silently ignore this attempt to write. */

    chksum = 0;
#if RT11
    if (fputc(FBR_LEAD1, fp) == EOF)   /* All recs begin with 1,0 */
        return 0;
    chksum -= FBR_LEAD1;
    if (fputc(FBR_LEAD2, fp) == EOF)
        return 0;
    chksum -= FBR_LEAD2;
#endif /* RT11 */

    i = hdrlen & 0xff;                 /* length, lsb */
    chksum -= i;
    if (fputc(i, fp) == EOF)
        return 0;

    i = (hdrlen >> 8) & 0xff;          /* length, msb */
    chksum -= i;
    if (fputc(i, fp) == EOF)
        return 0;

    i = fwrite(data, 1, len, fp);
    if (i < len)
        return 0;

    while (len > 0) {                  /* All the data bytes */
        chksum -= *data++ & 0xff;
        len--;
    }

    chksum &= 0xff;

#if RT11
    fputc(chksum, fp);                 /* Followed by the checksum byte */
#else /* RT11 */
    if (hdrlen & 1) {
        fputc(0, fp);                  /* Padding to even boundary */
    }
#endif /* RT11 */

    return 1;                          /* Worked okay. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1138c
movl $0x1, -0x4(%rbp)
jmp 0x11481
movl $0x0, -0x20(%rbp)
movl -0x28(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2150
cmpl $-0x1, %eax
jne 0x113c6
movl $0x0, -0x4(%rbp)
jmp 0x11481
movl -0x28(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2150
cmpl $-0x1, %eax
jne 0x113fc
movl $0x0, -0x4(%rbp)
jmp 0x11481
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x22c0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x11426
movl $0x0, -0x4(%rbp)
jmp 0x11481
jmp 0x11428
cmpl $0x0, -0x1c(%rbp)
jle 0x11459
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %ecx
andl $0xff, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11428
movl -0x20(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1147a
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x2150
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: gsd_write
static int gsd_write(
    GSD * gsd,
    char *name,
    int flags,
    int type,
    int value)
{
    char           *cp;
    unsigned        radtbl[2];

    if (gsd->offset > (int)sizeof(gsd->buf) - 8) {
        if (!gsd_flush(gsd))
            return 0;
    }

    rad50x2(name, radtbl);

    cp = gsd->buf + gsd->offset;
    *cp++ = radtbl[0] & 0xff;
    *cp++ = (radtbl[0] >> 8) & 0xff;
    *cp++ = radtbl[1] & 0xff;
    *cp++ = (radtbl[1] >> 8) & 0xff;

    *cp++ = flags;
    *cp++ = type;

    *cp++ = value & 0xff;
    *cp = (value >> 8) & 0xff;

    gsd->offset += 8;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x72, 0x84(%rax)
jle 0x11503
movq -0x10(%rbp), %rdi
callq 0x112f0
cmpl $0x0, %eax
jne 0x11501
movl $0x0, -0x4(%rbp)
jmp 0x11610
jmp 0x11503
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq 0x84(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x38(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x34(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x34(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x84(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_init
void text_init(
    TEXT_RLD *tr,
    FILE *fp,
    unsigned addr)
{
    tr->fp = fp;

    tr->text[0] = OBJ_TEXT;            /* text records begin with 3, 0 */
    tr->text[1] = 0;
    tr->text[2] = addr & 0xff;         /* and are followed by load address */
    tr->text[3] = (addr >> 8) & 0xff;
    tr->txt_offset = 4;                /* Here's where recording new text will begin */

    tr->rld[0] = OBJ_RLD;              /* RLD records begin with 4, 0 */
    tr->rld[1] = 0;

    tr->txt_addr = addr;
    tr->rld_offset = 2;                /* And are followed by RLD entries */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x3, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x9(%rax)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x8c(%rax)
movq -0x8(%rbp), %rax
movb $0x4, 0x90(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x91(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x110(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_flush
int text_flush(
    TEXT_RLD *tr)
{
    if (tr->txt_offset > 4) {
        if (!writerec(tr->fp, tr->text, tr->txt_offset))
            return 0;
    }

    if (tr->rld_offset > 2) {
        if (!writerec(tr->fp, tr->rld, tr->rld_offset))
            return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, 0x8c(%rax)
jle 0x118e7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %edx
callq 0x11360
cmpl $0x0, %eax
jne 0x118e5
movl $0x0, -0x4(%rbp)
jmp 0x1192c
jmp 0x118e7
movq -0x10(%rbp), %rax
cmpl $0x2, 0x110(%rax)
jle 0x11925
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
movq -0x10(%rbp), %rax
movl 0x110(%rax), %edx
callq 0x11360
cmpl $0x0, %eax
jne 0x11923
movl $0x0, -0x4(%rbp)
jmp 0x1192c
jmp 0x11925
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_word
int text_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word)
{
    if (!text_fit(tr, *addr, size, 0))
        return 0;

    text_word_i(tr, word, size);

    *addr += size;                     /* Update the caller's DOT */
    return 1;                          /* say "ok". */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x11978
movl $0x0, -0x4(%rbp)
jmp 0x11999
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_fit
static int text_fit(
    TEXT_RLD *tr,
    unsigned addr,
    int txtsize,
    int rldsize)
{
    if (tr->txt_offset + txtsize <= (int)sizeof(tr->text) &&
        tr->rld_offset + rldsize <= (int)sizeof(tr->rld) &&
        (txtsize == 0 || tr->txt_addr + tr->txt_offset - 4 == addr))
        return 1;                      /* All's well. */

    if (!text_flush(tr))
        return 0;
    text_init(tr, tr->fp, addr);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %eax
addl -0x18(%rbp), %eax
cmpl $0x80, %eax
jg 0x11a18
movq -0x10(%rbp), %rax
movl 0x110(%rax), %eax
addl -0x1c(%rbp), %eax
cmpl $0x80, %eax
jg 0x11a18
cmpl $0x0, -0x18(%rbp)
je 0x11a0f
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x8c(%rcx), %eax
subl $0x4, %eax
cmpl -0x14(%rbp), %eax
jne 0x11a18
movl $0x1, -0x4(%rbp)
jmp 0x11a49
movq -0x10(%rbp), %rdi
callq 0x118a0
cmpl $0x0, %eax
jne 0x11a2f
movl $0x0, -0x4(%rbp)
jmp 0x11a49
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x11810
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_internal_word
int text_internal_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word)
{
    if (!text_fit(tr, *addr, size, 4))
        return 0;

    text_word_i(tr, word, size);
    rld_code(tr, RLD_INT, *addr, size);
    rld_word(tr, word);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x4, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x11b0b
movl $0x0, -0x4(%rbp)
jmp 0x11b4f
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0x1, %esi
callq 0x11b60
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_global_word
int text_global_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *global)
{
    unsigned        radtbl[2];

    if (!text_fit(tr, *addr, size, 6))
        return 0;

    text_word_i(tr, word, size);
    rld_code(tr, RLD_GLOBAL, *addr, size);

    rad50x2(global, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x6, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x11c6f
movl $0x0, -0x4(%rbp)
jmp 0x11ccc
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0x2, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_displaced_word
int text_displaced_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word)
{
    if (!text_fit(tr, *addr, size, 4))
        return 0;

    text_word_i(tr, word, size);
    rld_code(tr, RLD_INT_DISP, *addr, size);
    rld_word(tr, word);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x4, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x11d1b
movl $0x0, -0x4(%rbp)
jmp 0x11d5f
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0x3, %esi
callq 0x11b60
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_global_displaced_word
int text_global_displaced_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *global)
{
    unsigned        radtbl[2];

    if (!text_fit(tr, *addr, size, 6))
        return 0;

    text_word_i(tr, word, size);
    rld_code(tr, RLD_GLOBAL_DISP, *addr, size);

    rad50x2(global, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x6, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x11daf
movl $0x0, -0x4(%rbp)
jmp 0x11e0c
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0x4, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_global_offset_word
int text_global_offset_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *global)
{
    unsigned        radtbl[2];

    if (word == 0)
        return text_global_word(tr, addr, size, word, global);

    if (!text_fit(tr, *addr, size, 8))
        return 0;

    text_word_i(tr, word, size);

    rld_code(tr, RLD_GLOBAL_OFFSET, *addr, size);

    rad50x2(global, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);
    rld_word(tr, word);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x11e5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x11c30
movl %eax, -0x4(%rbp)
jmp 0x11eed
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x8, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x11e84
movl $0x0, -0x4(%rbp)
jmp 0x11eed
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0x5, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_global_displaced_offset_word
int text_global_displaced_offset_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *global)
{
    unsigned        radtbl[2];

    if (word == 0)
        return text_global_displaced_word(tr, addr, size, word, global);

    if (!text_fit(tr, *addr, size, 8))
        return 0;

    text_word_i(tr, word, size);
    rld_code(tr, RLD_GLOBAL_OFFSET_DISP, *addr, size);

    rad50x2(global, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);
    rld_word(tr, word);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x11f3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x11d70
movl %eax, -0x4(%rbp)
jmp 0x11fcd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x8, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x11f64
movl $0x0, -0x4(%rbp)
jmp 0x11fcd
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0x6, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_define_location
int text_define_location(
    TEXT_RLD *tr,
    char *name,
    unsigned *addr)
{
    unsigned        radtbl[2];

    if (!text_fit(tr, *addr, 0, 8))    /* No text space used */
        return 0;

    rld_code_naddr(tr, RLD_LOCDEF, 2); /* RLD code for "location
                                          counter def" with no offset */

    rad50x2(name, radtbl);
    rld_word(tr, radtbl[0]);           /* Set current section name */
    rld_word(tr, radtbl[1]);
    rld_word(tr, *addr);               /* Set current location addr */

    if (!text_flush(tr))               /* Flush that block out. */
        return 0;

    text_init(tr, tr->fp, *addr);      /* Set new text address */

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
movl $0x8, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x12018
movl $0x0, -0x4(%rbp)
jmp 0x12093
movq -0x10(%rbp), %rdi
movl $0x7, %esi
movl $0x2, %edx
callq 0x120a0
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
callq 0x118a0
cmpl $0x0, %eax
jne 0x12076
movl $0x0, -0x4(%rbp)
jmp 0x12093
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0x11810
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_modify_location
int text_modify_location(
    TEXT_RLD *tr,
    unsigned *addr)
{
    if (!text_fit(tr, *addr, 0, 4))    /* No text space used */
        return 0;

    rld_code_naddr(tr, RLD_LOCMOD, 2); /* RLD code for "location
                                          counter mod" with no offset */
    rld_word(tr, *addr);               /* Set current location addr */

    if (!text_flush(tr))               /* Flush that block out. */
        return 0;
    text_init(tr, tr->fp, *addr);      /* Set new text address */

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
movl $0x4, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x12114
movl $0x0, -0x4(%rbp)
jmp 0x1216a
movq -0x10(%rbp), %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x120a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
callq 0x118a0
cmpl $0x0, %eax
jne 0x1214d
movl $0x0, -0x4(%rbp)
jmp 0x1216a
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x11810
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_limits
int text_limits(
    TEXT_RLD *tr,
    unsigned *addr)
{
    if (!text_fit(tr, *addr, 4, 2))
        return 0;

    text_word_i(tr, 0, 2);
    text_word_i(tr, 0, 2);
    rld_code(tr, RLD_LIMITS, *addr, 2);

    *addr += 4;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0x4, %edx
movl $0x2, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x121b7
movl $0x0, -0x4(%rbp)
jmp 0x12202
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl $0x9, %esi
movl $0x2, %ecx
callq 0x11b60
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_psect_word
int text_psect_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *name)
{
    unsigned        radtbl[2];

    if (!text_fit(tr, *addr, size, 6))
        return 0;

    text_word_i(tr, word, size);

    rld_code(tr, RLD_PSECT, *addr, size);

    rad50x2(name, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x6, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x1224f
movl $0x0, -0x4(%rbp)
jmp 0x122ac
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0xa, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_psect_offset_word
int text_psect_offset_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *name)
{
    unsigned        radtbl[2];

#if OPTIMIZE_ZERO_OFFSET
    if (word == 0)
        return text_psect_word(tr, addr, size, word, name);
#endif

    if (!text_fit(tr, *addr, size, 8))
        return 0;

    text_word_i(tr, word, size);

    rld_code(tr, RLD_PSECT_OFFSET, *addr, size);

    rad50x2(name, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);
    rld_word(tr, word);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x8, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x122ff
movl $0x0, -0x4(%rbp)
jmp 0x12368
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0xd, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_psect_displaced_word
int text_psect_displaced_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *name)
{
    unsigned        radtbl[2];

    if (!text_fit(tr, *addr, size, 6))
        return 0;

    text_word_i(tr, word, size);

    rld_code(tr, RLD_PSECT_DISP, *addr, size);

    rad50x2(name, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x6, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x123bf
movl $0x0, -0x4(%rbp)
jmp 0x1241c
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0xc, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_psect_displaced_offset_word
int text_psect_displaced_offset_word(
    TEXT_RLD *tr,
    unsigned *addr,
    int size,
    unsigned word,
    char *name)
{
    unsigned        radtbl[2];

#if OPTIMIZE_ZERO_OFFSET
    if (word == 0)
        return text_psect_displaced_word(tr, addr, size, word, name);
#endif

    if (!text_fit(tr, *addr, size, 8))
        return 0;

    text_word_i(tr, word, size);

    rld_code(tr, RLD_PSECT_OFFSET_DISP, *addr, size);

    rad50x2(name, radtbl);
    rld_word(tr, radtbl[0]);
    rld_word(tr, radtbl[1]);
    rld_word(tr, word);

    *addr += size;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x8, %ecx
callq 0x119b0
cmpl $0x0, %eax
jne 0x1246f
movl $0x0, -0x4(%rbp)
jmp 0x124d8
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x11a60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
movl $0xe, %esi
callq 0x11b60
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13b40
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11bc0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x11bc0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_complex_byte
static int text_complex_byte(
    TEXT_COMPLEX *tx,
    unsigned byte)
{
    char           *cp = text_complex_fit(tx, 1);

    if (!cp)
        return 0;
    *cp = byte;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x12710
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12561
movl $0x0, -0x4(%rbp)
jmp 0x12573
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_complex_lit
int text_complex_lit(
    TEXT_COMPLEX *tx,
    unsigned word)
{
    char           *cp = text_complex_fit(tx, 3);

    if (!cp)
        return 0;
    *cp++ = CPLX_CONST;
    *cp++ = word & 0xff;
    *cp = (word >> 8) & 0xff;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x12710
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x126b1
movl $0x0, -0x4(%rbp)
jmp 0x126f8
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x10, (%rax)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/object.c
// Function: text_complex_fit
static char    *text_complex_fit(
    TEXT_COMPLEX *tx,
    int size)
{
    int             len;

    if (tx->len + size > (int)sizeof(tx->accum))
        return NULL;                   /* Expression has grown too complex. */

    len = tx->len;

    tx->len += size;

    return tx->accum + len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
addl -0x14(%rbp), %eax
cmpl $0x7e, %eax
jle 0x12737
movq $0x0, -0x8(%rbp)
jmp 0x12766
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x80(%rax), %ecx
movl %ecx, 0x80(%rax)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)