LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/extree.c
// Function: dup_symbol
SYMBOL *dup_symbol(
    SYMBOL *sym)
{
    SYMBOL *res;

    if (sym == NULL) {
        return NULL;
    }

    res = memcheck(malloc(sizeof(SYMBOL)));
    res->label = memcheck(strdup(sym->label));
    res->flags = sym->flags;
    res->stmtno = sym->stmtno;
    res->next = NULL;
    res->section = sym->section;
    res->value = sym->value;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9460
movq $0x0, -0x8(%rbp)
jmp 0x94e2
movl $0x28, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x136a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/extree.c
// Function: dup_tree
EX_TREE *dup_tree(
    EX_TREE *tp)
{
    EX_TREE *res = NULL;

    if (tp == NULL) {
        return NULL;
    }

    res = new_ex_tree();
    res->type = tp->type;
    res->cp = tp->cp;

    switch (tp->type) {
    case EX_UNDEFINED_SYM:
    case EX_TEMP_SYM:
        res->data.symbol = dup_symbol(tp->data.symbol);
        break;

    /* The symbol reference in EX_SYM is not freed in free_tree() */
    case EX_SYM:
        res->data.symbol = tp->data.symbol;
        break;

    case EX_LIT:
        res->data.lit = tp->data.lit;
        break;

    case EX_COM:
    case EX_NEG:
    case EX_ERR:
        res->data.child.left = dup_tree(tp->data.child.left);
        break;

    case EX_ADD:
    case EX_SUB:
    case EX_MUL:
    case EX_DIV:
    case EX_AND:
    case EX_OR:
        res->data.child.left = dup_tree(tp->data.child.left);
        res->data.child.right = dup_tree(tp->data.child.right);
        break;
    }

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9518
movq $0x0, -0x8(%rbp)
jmp 0x95f6
callq 0x9600
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xc, %eax
ja 0x95ee
movq -0x20(%rbp), %rax
leaq 0xbee5(%rip), %rcx      # 0x15444
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9440
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x95ee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x95ee
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x95ee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x94f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x95ee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x94f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x94f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/extree.c
// Function: new_temp_sym
static EX_TREE *new_temp_sym(
    char *label,
    SECTION *section,
    unsigned value)
{
    SYMBOL         *sym;
    EX_TREE        *tp;

    sym = memcheck(malloc(sizeof(SYMBOL)));
    sym->label = memcheck(strdup(label));
    sym->flags = 0;
    sym->stmtno = stmtno;
    sym->next = NULL;
    sym->section = section;
    sym->value = value;

    tp = new_ex_tree();
    tp->type = EX_TEMP_SYM;
    tp->data.symbol = sym;

    return tp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x28, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x136a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
leaq 0xf81e(%rip), %rax      # 0x19b84
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
callq 0x9600
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/extree.c
// Function: new_ex_lit
EX_TREE        *new_ex_lit(
    unsigned value)
{
    EX_TREE        *tp;

    tp = new_ex_tree();
    tp->type = EX_LIT;
    tp->data.lit = value;

    return tp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x9600
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/extree.c
// Function: new_ex_bin
EX_TREE        *new_ex_bin(
    int type,
    EX_TREE *left,
    EX_TREE *right)
{
    EX_TREE        *tp;

    tp = new_ex_tree();
    tp->type = type;
    tp->data.child.left = left;
    tp->data.child.right = right;

    return tp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x9600
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/extree.c
// Function: ex_err
EX_TREE        *ex_err(
    EX_TREE *tp,
    char *cp)
{
    EX_TREE        *errtp;

    errtp = new_ex_tree();
    errtp->cp = cp;
    errtp->type = EX_ERR;
    errtp->data.child.left = tp;

    return errtp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x9600
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x7, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: list_source
void list_source(
    STREAM *str,
    char *cp)
{
    if (dolist()) {
        int             len = strcspn(cp, "\n");

        /* Save the line text away for later... */
        if (listline)
            free(listline);
        listline = memcheck(malloc(len + 1));
        memcpy(listline, cp, len);
        listline[len] = 0;

        if (!binline)
            binline = memcheck(malloc(sizeof(LSTFORMAT) + 16));

        sprintf(binline, "%*s%*d", (int)SIZEOF_MEMBER(LSTFORMAT, flag), "", (int)SIZEOF_MEMBER(LSTFORMAT, line_number),
                str->line);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xa580
cmpl $0x0, %eax
je 0xa579
movq -0x10(%rbp), %rdi
leaq 0xb736(%rip), %rsi      # 0x15bff
callq 0x2160
movl %eax, -0x14(%rbp)
cmpq $0x0, 0x111b7(%rip)     # 0x1b690
je 0xa4e7
movq 0x111ae(%rip), %rdi     # 0x1b690
callq 0x2040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, 0x1118c(%rip)     # 0x1b690
movq 0x11185(%rip), %rdi     # 0x1b690
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2200
movq 0x11171(%rip), %rax     # 0x1b690
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, 0x11169(%rip)     # 0x1b698
jne 0xa54a
movl $0x39, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, 0x1114e(%rip)     # 0x1b698
movq 0x11147(%rip), %rdi     # 0x1b698
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
leaq 0xafad(%rip), %rsi      # 0x1550d
movl $0x2, %edx
leaq 0xb793(%rip), %rcx      # 0x15cff
movl $0x6, %r8d
movb $0x0, %al
callq 0x22a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: dolist
static int dolist(
    void)
{
    int             ok = lstfile != NULL &&
                         (pass > 0 || list_pass_0) &&
                         list_level > 0;

    return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpq $0x0, 0x110f2(%rip)     # 0x1b680
movb %al, -0x5(%rbp)
je 0xa5ba
leaq 0xf5e6(%rip), %rax      # 0x19b80
cmpl $0x0, (%rax)
jg 0xa5ad
xorl %eax, %eax
cmpl $0x0, 0x110e0(%rip)     # 0x1b688
movb %al, -0x5(%rbp)
je 0xa5ba
cmpl $0x0, 0xf4bc(%rip)      # 0x19a70
setg %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: list_flush
void list_flush(
    void)
{
    if (dolist()) {
        padto(binline, offsetof(LSTFORMAT, source));
        fputs(binline, lstfile);
        fputs(listline, lstfile);
        fputc('\n', lstfile);
        listline[0] = 0;
        binline[0] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xa580
cmpl $0x0, %eax
je 0xa63a
movq 0x110b3(%rip), %rdi     # 0x1b698
movl $0x28, %esi
callq 0x13760
movq 0x110a2(%rip), %rdi     # 0x1b698
movq 0x11083(%rip), %rsi     # 0x1b680
callq 0x2110
movq 0x11087(%rip), %rdi     # 0x1b690
movq 0x11070(%rip), %rsi     # 0x1b680
callq 0x2110
movq 0x11064(%rip), %rsi     # 0x1b680
movl $0xa, %edi
callq 0x2150
movq 0x11063(%rip), %rax     # 0x1b690
movb $0x0, (%rax)
movq 0x11061(%rip), %rax     # 0x1b698
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: list_value
void list_value(
    STREAM *str,
    unsigned word)
{
    if (dolist()) {
        /* Print the value and go */
        binline[0] = 0;
        sprintf(binline, "%*s%*d        %6.6o", (int)SIZEOF_MEMBER(LSTFORMAT, flag), "",
                (int)SIZEOF_MEMBER(LSTFORMAT, line_number), str->line, word & 0177777);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0xa580
cmpl $0x0, %eax
je 0xa69d
movq 0x11038(%rip), %rax     # 0x1b698
movb $0x0, (%rax)
movq 0x1102e(%rip), %rdi     # 0x1b698
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
leaq 0xae93(%rip), %rsi      # 0x15514
movl $0x2, %edx
leaq 0xb672(%rip), %rcx      # 0x15cff
movl $0x6, %r8d
movl %eax, (%rsp)
movb $0x0, %al
callq 0x22a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: list_word
void list_word(
    STREAM *str,
    unsigned addr,
    unsigned value,
    int size,
    char *flags)
{
    if (dolist()) {
        list_fit(str, addr);
        if (size == 1)
            sprintf(binline + strlen(binline), "   %3.3o%1.1s ", value & 0377, flags);
        else
            sprintf(binline + strlen(binline), "%6.6o%1.1s ", value & 0177777, flags);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
callq 0xa580
cmpl $0x0, %eax
je 0xa75f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xa770
cmpl $0x1, -0x14(%rbp)
jne 0xa724
movq 0x10fa8(%rip), %rax     # 0x1b698
movq %rax, -0x28(%rbp)
movq 0x10f9d(%rip), %rdi     # 0x1b698
callq 0x20c0
movq -0x28(%rbp), %rdi
addq %rax, %rdi
movl -0x10(%rbp), %edx
andl $0xff, %edx
movq -0x20(%rbp), %rcx
leaq 0xae0d(%rip), %rsi      # 0x15528
movb $0x0, %al
callq 0x22a0
jmp 0xa75d
movq 0x10f6d(%rip), %rax     # 0x1b698
movq %rax, -0x30(%rbp)
movq 0x10f62(%rip), %rdi     # 0x1b698
callq 0x20c0
movq -0x30(%rbp), %rdi
addq %rax, %rdi
movl -0x10(%rbp), %edx
andl $0xffff, %edx           # imm = 0xFFFF
movq -0x20(%rbp), %rcx
leaq 0xade1(%rip), %rsi      # 0x15537
movb $0x0, %al
callq 0x22a0
jmp 0xa75f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: list_fit
static void list_fit(
    STREAM *str,
    unsigned addr)
{
    size_t          col1 = offsetof(LSTFORMAT, source);
    size_t          col2 = offsetof(LSTFORMAT, pc);

    if (strlen(binline) >= col1) {
        list_flush();
        listline[0] = 0;
        binline[0] = 0;
        sprintf(binline, "%*s %6.6o", (int)offsetof(LSTFORMAT, pc), "", addr);
        padto(binline, offsetof(LSTFORMAT, words));
    } else if (strlen(binline) <= col2) {
        sprintf(binline, "%*s%*d %6.6o", (int)SIZEOF_MEMBER(LSTFORMAT, flag), "",
                (int)SIZEOF_MEMBER(LSTFORMAT, line_number), str->line, addr);
        padto(binline, offsetof(LSTFORMAT, words));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x28, -0x18(%rbp)
movq $0x8, -0x20(%rbp)
movq 0x10f02(%rip), %rdi     # 0x1b698
callq 0x20c0
cmpq -0x18(%rbp), %rax
jb 0xa7f2
callq 0xa5d0
movq 0x10ee3(%rip), %rax     # 0x1b690
movb $0x0, (%rax)
movq 0x10ee1(%rip), %rax     # 0x1b698
movb $0x0, (%rax)
movq 0x10ed7(%rip), %rdi     # 0x1b698
movl -0xc(%rbp), %r8d
leaq 0xad88(%rip), %rsi      # 0x15554
movl $0x8, %edx
leaq 0xb527(%rip), %rcx      # 0x15cff
movb $0x0, %al
callq 0x22a0
movq 0x10eb2(%rip), %rdi     # 0x1b698
movl $0x10, %esi
callq 0x13760
jmp 0xa84c
movq 0x10e9f(%rip), %rdi     # 0x1b698
callq 0x20c0
cmpq -0x20(%rbp), %rax
ja 0xa84a
movq 0x10e8d(%rip), %rdi     # 0x1b698
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movl -0xc(%rbp), %eax
leaq 0xad41(%rip), %rsi      # 0x1555e
movl $0x2, %edx
leaq 0xb4d6(%rip), %rcx      # 0x15cff
movl $0x6, %r8d
movl %eax, (%rsp)
movb $0x0, %al
callq 0x22a0
movq 0x10e58(%rip), %rdi     # 0x1b698
movl $0x10, %esi
callq 0x13760
jmp 0xa84c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: report
void report(
    STREAM *str,
    char *fmt,
    ...)
{
    va_list         ap;
    char           *name = "**";
    int             line = 0;

    if (!pass && list_pass_0 < 2)
        return;                        /* Don't report now. */

    if (str) {
        name = str->name;
        line = str->line;
    }

    fprintf(stderr, "%s:%d: ***ERROR ", name, line);
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);

    if (lstfile) {
        fprintf(lstfile, "%s:%d: ***ERROR ", name, line);
        va_start(ap, fmt);
        vfprintf(lstfile, fmt, ap);
        va_end(ap);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xa8cb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xb2de(%rip), %rax      # 0x15bd4
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
leaq 0xf278(%rip), %rax      # 0x19b80
cmpl $0x0, (%rax)
jne 0xa91b
cmpl $0x2, 0x10d74(%rip)     # 0x1b688
jge 0xa91b
jmp 0xa9f8
cmpq $0x0, -0x8(%rbp)
je 0xa938
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x3c(%rbp)
movq 0xe6b9(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
movq -0x38(%rbp), %rdx
movl -0x3c(%rbp), %ecx
leaq 0xabf3(%rip), %rsi      # 0x15543
movb $0x0, %al
callq 0x21c0
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xe676(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2270
leaq -0x30(%rbp), %rax
cmpq $0x0, 0x10ce2(%rip)     # 0x1b680
je 0xa9f8
movq 0x10cd9(%rip), %rdi     # 0x1b680
movq -0x38(%rbp), %rdx
movl -0x3c(%rbp), %ecx
leaq 0xab8e(%rip), %rsi      # 0x15543
movb $0x0, %al
callq 0x21c0
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x10c99(%rip), %rdi     # 0x1b680
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2270
leaq -0x30(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: new_macro_stream
STREAM         *new_macro_stream(
    STREAM *refstr,
    BUFFER *buf,
    MACRO *mac,
    int nargs)
{
    MACRO_STREAM   *mstr = memcheck(malloc(sizeof(MACRO_STREAM))); {
        char           *name = memcheck(malloc(strlen(refstr->name) + 32));

        sprintf(name, "%s:%d->%s", refstr->name, refstr->line, mac->sym.label);
        buffer_stream_construct(&mstr->bstr, buf, name);
        free(name);
    }

    mstr->bstr.stream.vtbl = &macro_stream_vtbl;
    mstr->nargs = nargs;  /* for .NARG directive: nonkeyword arguments in call*/
    mstr->cond = last_cond;
    return &mstr->bstr.stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x38, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %r8
leaq 0xaab8(%rip), %rsi      # 0x1556b
movb $0x0, %al
callq 0x22a0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x12f90
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rax
leaq 0xef99(%rip), %rcx      # 0x19a78
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
leaq 0x109dd(%rip), %rax     # 0x1b4d0
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: dumpmacro
void dumpmacro(
    MACRO *mac,
    FILE *fp)
{
    ARG            *arg;

    fprintf(fp, ".MACRO %s ", mac->sym.label);

    for (arg = mac->args; arg != NULL; arg = arg->next) {
        fputs(arg->label, fp);
        if (arg->value) {
            fputc('=', fp);
            fputs(arg->value, fp);
        }
        fputc(' ', fp);
    }
    fputc('\n', fp);

    fputs(mac->text->buffer, fp);

    fputs(".ENDM\n", fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xa8a9(%rip), %rsi      # 0x155bb
movb $0x0, %al
callq 0x21c0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xad82
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2110
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xad67
movq -0x10(%rbp), %rsi
movl $0x3d, %edi
callq 0x2150
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2110
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x2150
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xad25
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x2150
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2110
movq -0x10(%rbp), %rsi
leaq 0xa817(%rip), %rdi      # 0x155c6
callq 0x2110
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: free_macro
void free_macro(
    MACRO *mac)
{
    if (mac->text) {
        free(mac->text);
    }
    free_args(mac->args);
    free_sym(&mac->sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xb0a4
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xb8f0
movq -0x8(%rbp), %rdi
callq 0xdf70
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: new_macro
MACRO          *new_macro(
    char *label)
{
    MACRO          *mac = memcheck(malloc(sizeof(MACRO)));

    mac->sym.flags = 0;
    mac->sym.label = label;
    mac->sym.stmtno = stmtno;
    mac->sym.next = NULL;
    mac->sym.section = &macro_section;
    mac->sym.value = 0;
    mac->args = NULL;
    mac->text = NULL;

    return mac;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq 0xea85(%rip), %rax      # 0x19b84
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0xe0e1(%rip), %rcx      # 0x19200
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: new_arg
ARG            *new_arg(
    void)
{
    ARG            *arg = memcheck(malloc(sizeof(ARG)));

    arg->locsym = 0;
    arg->value = NULL;
    arg->next = NULL;
    arg->label = NULL;
    return arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: find_arg
static ARG     *find_arg(
    ARG *arg,
    char *name)
{
    for (; arg != NULL; arg = arg->next)
        if (strcmp(arg->label, name) == 0)
            return arg;

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb3c6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21b0
cmpl $0x0, %eax
jne 0xb3b7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb3ce
jmp 0xb3b9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb390
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: eval_str
char *eval_str(
    STREAM *refstr,
    char *arg)
{
    EX_TREE        *value = parse_expr(arg, 0);
    unsigned        word = 0;
    char            temp[10];

    if (value->type != EX_LIT) {
        report(refstr, "Constant value required\n");
    } else
        word = value->data.lit;

    free_tree(value);

    /* printf can't do base 2. */
    my_ultoa(word & 0177777, temp, radix);
    free(arg);
    arg = memcheck(strdup(temp));
    return arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xc7b0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0xb423
movq -0x8(%rbp), %rdi
leaq 0xa1e5(%rip), %rsi      # 0x155ff
movb $0x0, %al
callq 0xa890
jmp 0xb42d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9390
movl -0x1c(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, %eax
movl %eax, %edi
leaq -0x26(%rbp), %rsi
leaq 0xdd43(%rip), %rax      # 0x19190
movl (%rax), %edx
callq 0x13420
movq -0x10(%rbp), %rdi
callq 0x2040
leaq -0x26(%rbp), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: getstring_macarg
char           *getstring_macarg(
    STREAM *refstr,
    char *cp,
    char **endp)
{
    if (cp[0] == '\\') {
        char *str = getstring(cp + 1, endp);
        return eval_str(refstr, str);         /* Perform expression evaluation */
    } else {
        return getstring(cp, endp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xb4c8
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movq -0x20(%rbp), %rsi
callq 0xbad0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xb3e0
movq %rax, -0x8(%rbp)
jmp 0xb4d9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xbad0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: free_args
static void free_args(
    ARG *arg)
{
    ARG            *next;

    while (arg) {
        next = arg->next;
        if (arg->label) {
            free(arg->label);
            arg->label = NULL;
        }
        if (arg->value) {
            free(arg->value);
            arg->value = NULL;
        }
        free(arg);
        arg = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb969
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb932
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb956
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb8fc
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: dump_all_macros
void dump_all_macros(
    void)
{
    MACRO          *mac;
    SYMBOL_ITER     iter;

    for (mac = (MACRO *) first_sym(&macro_st, &iter); mac != NULL; mac = (MACRO *) next_sym(&macro_st, &iter)) {
        dumpmacro(mac, lstfile);

        fprintf(lstfile, "\n\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x15d59(%rip), %rdi     # 0x216d8
leaq -0x18(%rbp), %rsi
callq 0xe150
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb9d4
movq -0x8(%rbp), %rdi
leaq 0xfce2(%rip), %rax      # 0x1b680
movq (%rax), %rsi
callq 0xacf0
leaq 0xfcd3(%rip), %rax      # 0x1b680
movq (%rax), %rdi
leaq 0xa247(%rip), %rsi      # 0x15bfe
movb $0x0, %al
callq 0x21c0
leaq 0x15d13(%rip), %rdi     # 0x216d8
leaq -0x18(%rbp), %rsi
callq 0xe0c0
movq %rax, -0x8(%rbp)
jmp 0xb98c
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/parse.c
// Function: skipdelim
char           *skipdelim(
    char *cp)
{
    cp = skipwhite(cp);
    if (*cp == ',')
        cp = skipwhite(cp + 1);
    return cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb9e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xba66
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0xb9e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/parse.c
// Function: skipdelim_comma
char           *skipdelim_comma(
    char *cp,
    int  *comma)
{
    cp = skipwhite(cp);
    if ((*comma = (*cp == ','))) {
        cp = skipwhite(cp + 1);
    }
    return cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb9e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %edx
movq -0x10(%rbp), %rcx
movl %edx, (%rcx)
testb $0x1, %al
jne 0xbaae
jmp 0xbabf
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0xb9e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/parse.c
// Function: getstring
char           *getstring(
    char *cp,
    char **endp)
{
    int             len;
    int             start;
    char           *str;

    if (!brackrange(cp, &start, &len, endp)) {
        start = 0;
        len = strcspn(cp, " \t\n,;");
        if (endp)
            *endp = cp + len;
    }

    str = memcheck(malloc(len + 1));
    memcpy(str, cp + start, len);
    str[len] = 0;

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0xbb80
cmpl $0x0, %eax
jne 0xbb2f
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9bec(%rip), %rsi      # 0x156f8
callq 0x2160
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbb2d
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbb2f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2200
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/parse.c
// Function: getstring_fn
char           *getstring_fn(
    char *cp,
    char **endp)
{
    char            endstr[4];
    int             len;
    char           *str;

    switch (*cp) {
    case '<':
    case ':':
        return NULL;
    }

    if (!ispunct((unsigned char)*cp)) {
        return NULL;
    }

    endstr[0] = *cp;
    endstr[1] = '\n';
    endstr[2] = '\0';
    cp++;

    len = strcspn(cp, endstr);

    if (endp)
        *endp = cp + len + 1;

    str = memcheck(malloc(len + 1));
    memcpy(str, cp, len);
    str[len] = 0;

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x3a, %eax
je 0xbd5b
jmp 0xbd51
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
jne 0xbd68
jmp 0xbd5b
movq $0x0, -0x8(%rbp)
jmp 0xbe1c
callq 0x22e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xbd93
movq $0x0, -0x8(%rbp)
jmp 0xbe1c
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x1c(%rbp)
movb $0xa, -0x1b(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x2160
movl %eax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbddd
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rax
addq %rax, %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x2200
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/parse.c
// Function: get_op
SYMBOL         *get_op(
    char *cp,
    char **endp)
{
    int             local;
    char           *label;
    SYMBOL         *op;

    cp = skipwhite(cp);
    if (EOL(*cp))
        return NULL;

    label = get_symbol(cp, &cp, &local);
    if (label == NULL)
        return NULL;                   /* No operation code. */

    cp = skipwhite(cp);
    if (*cp == ':') {                  /* A label definition? */
        cp++;
        if (*cp == ':')
            cp++;                      /* Skip it */
        free(label);
        label = get_symbol(cp, &cp, NULL);
        if (label == NULL)
            return NULL;
    }

    op = lookup_sym(label, &system_st);
    free(label);

    if (endp)
        *endp = cp;

    return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb9e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xbe6e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xbe6e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0xbe7b
movq $0x0, -0x8(%rbp)
jmp 0xbf49
movq -0x10(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xbf60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xbea4
movq $0x0, -0x8(%rbp)
jmp 0xbf49
movq -0x10(%rbp), %rdi
callq 0xb9e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0xbf12
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0xbee1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
leaq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbf60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xbf10
movq $0x0, -0x8(%rbp)
jmp 0xbf49
jmp 0xbf12
movq -0x28(%rbp), %rdi
leaq 0x1178b(%rip), %rsi     # 0x1d6a8
callq 0xe040
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2040
cmpq $0x0, -0x18(%rbp)
je 0xbf41
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/parse.c
// Function: parse_expr
EX_TREE        *parse_expr(
    char *cp,
    int undef)
{
    EX_TREE        *expr;
    EX_TREE        *value;

    expr = parse_binary(cp, 0, 0);     /* Parse into a tree */
    value = evaluate(expr, undef);     /* Perform the arithmetic */
    value->cp = expr->cp;              /* Pointer to end of text is part of
                                          the rootmost node  */
    free_tree(expr);                   /* Discard parse in favor of
                                          evaluation */

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xca40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x9630
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x9390
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/parse.c
// Function: parse_unary_expr
EX_TREE        *parse_unary_expr(
    char *cp,
    int undef)
{
    EX_TREE        *expr;
    EX_TREE        *value;

    expr = parse_unary(cp);            /* Parse into a tree */
    value = evaluate(expr, undef);     /* Perform the arithmetic */
    value->cp = expr->cp;              /* Pointer to end of text is part of
                                          the rootmost node  */
    free_tree(expr);                   /* Discard parse in favor of
                                          evaluation */

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcd30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x9630
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x9390
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/rept_irpc.c
// Function: rept_stream_gets
char           *rept_stream_gets(
    STREAM *str)
{
    REPT_STREAM    *rstr = (REPT_STREAM *) str;
    char           *cp;

    for (;;) {
        if ((cp = buffer_stream_gets(str)) != NULL)
            return cp;

        if (--rstr->count <= 0)
            return NULL;

        buffer_stream_rewind(str);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xd581
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd5a8
movq -0x18(%rbp), %rcx
movl 0x30(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x30(%rcx)
cmpl $0x0, %eax
jg 0xd59d
movq $0x0, -0x8(%rbp)
jmp 0xd5a8
movq -0x10(%rbp), %rdi
callq 0x12f60
jmp 0xd564
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/rept_irpc.c
// Function: expand_rept
STREAM         *expand_rept(
    STACK *stack,
    char *cp)
{
    EX_TREE        *value;
    BUFFER         *gb;
    REPT_STREAM    *rstr;
    int             levelmod;

    value = parse_expr(cp, 0);
    if (value->type != EX_LIT) {
        report(stack->top, ".REPT value must be constant\n");
        free_tree(value);
        return NULL;
    }

    gb = new_buffer();

    levelmod = 0;
    if (!list_md) {
        list_level--;
        levelmod = 1;
    }

    read_body(stack, gb, NULL, FALSE);

    list_level += levelmod;

    rstr = memcheck(malloc(sizeof(REPT_STREAM))); {
        char           *name = memcheck(malloc(strlen(stack->top->name) + 32));

        sprintf(name, "%s:%d->.REPT", stack->top->name, stack->top->line);
        buffer_stream_construct(&rstr->bstr, gb, name);
        free(name);
    }

    rstr->count = value->data.lit;
    rstr->bstr.stream.vtbl = &rept_stream_vtbl;
    rstr->savecond = last_cond;

    buffer_free(gb);
    free_tree(value);

    return &rstr->bstr.stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xc7b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0xd643
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x80fb(%rip), %rsi      # 0x15721
movb $0x0, %al
callq 0xa890
movq -0x20(%rbp), %rdi
callq 0x9390
movq $0x0, -0x8(%rbp)
jmp 0xd768
callq 0x12af0
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
leaq 0xc40a(%rip), %rax      # 0x19a64
cmpl $0x0, (%rax)
jne 0xd67b
leaq 0xc40a(%rip), %rax      # 0x19a70
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0xc3fe(%rip), %rax      # 0x19a70
movl %ecx, (%rax)
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0xab10
movl -0x34(%rbp), %ecx
leaq 0xc3d8(%rip), %rax      # 0x19a70
addl (%rax), %ecx
leaq 0xc3cf(%rip), %rax      # 0x19a70
movl %ecx, (%rax)
movl $0x38, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
leaq 0x803e(%rip), %rsi      # 0x1573f
movb $0x0, %al
callq 0x22a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x12f90
movq -0x40(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rax
leaq 0xc355(%rip), %rcx      # 0x19a90
movq %rcx, (%rax)
leaq 0xdd8b(%rip), %rax      # 0x1b4d0
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x28(%rbp), %rdi
callq 0x12c20
movq -0x20(%rbp), %rdi
callq 0x9390
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/rept_irpc.c
// Function: irp_stream_gets
char           *irp_stream_gets(
    STREAM *str)
{
    IRP_STREAM     *istr = (IRP_STREAM *) str;
    char           *cp;
    BUFFER         *buf;
    ARG            *arg;

    for (;;) {
        if ((cp = buffer_stream_gets(str)) != NULL)
            return cp;

        cp = istr->items + istr->offset;

        if (!*cp)
            return NULL;               /* No more items.  EOF. */

        arg = new_arg();
        arg->next = NULL;
        arg->locsym = 0;
        arg->label = istr->label;
        arg->value = getstring_macarg(str, cp, &cp);
        cp = skipdelim(cp);
        istr->offset = (int) (cp - istr->items);

        buf = subst_args(istr->body, arg);

        free(arg->value);
        free(arg);
        buffer_stream_set_buffer(&istr->bstr, buf);
        buffer_free(buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xd7b4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd897
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x40(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xd7e1
movq $0x0, -0x8(%rbp)
jmp 0xd897
callq 0xb150
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xb480
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0xba30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xb1b0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13000
movq -0x28(%rbp), %rdi
callq 0x12c20
jmp 0xd794
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/rept_irpc.c
// Function: irp_stream_delete
void irp_stream_delete(
    STREAM *str)
{
    IRP_STREAM     *istr = (IRP_STREAM *) str;

    pop_cond(istr->savecond);          /* complete unterminated
                                          conditionals */

    buffer_free(istr->body);
    free(istr->items);
    free(istr->label);
    buffer_stream_delete(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x8880
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x12c20
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x12f30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/rept_irpc.c
// Function: irpc_stream_gets
char           *irpc_stream_gets(
    STREAM *str)
{
    IRPC_STREAM    *istr = (IRPC_STREAM *) str;
    char           *cp;
    BUFFER         *buf;
    ARG            *arg;

    for (;;) {
        if ((cp = buffer_stream_gets(str)) != NULL)
            return cp;

        cp = istr->items + istr->offset;

        if (!*cp)
            return NULL;               /* No more items.  EOF. */

        arg = new_arg();
        arg->next = NULL;
        arg->locsym = 0;
        arg->label = istr->label;
        arg->value = memcheck(malloc(2));
        arg->value[0] = *cp++;
        arg->value[1] = 0;
        istr->offset = (int) (cp - istr->items);

        buf = subst_args(istr->body, arg);

        free(arg->value);
        free(arg);
        buffer_stream_set_buffer(&istr->bstr, buf);
        buffer_free(buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xdb34
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdc32
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x40(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xdb61
movq $0x0, -0x8(%rbp)
jmp 0xdc32
callq 0xb150
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x2, %edi
callq 0x2220
movq %rax, %rdi
callq 0x136a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, 0x1(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xb1b0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13000
movq -0x28(%rbp), %rdi
callq 0x12c20
jmp 0xdb14
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/symbols.c
// Function: hash_name
int hash_name(
    char *label)
{
    unsigned        accum = 0;

    while (*label)
        accum = (accum << 1) ^ *label++;

    accum %= HASH_SIZE;

    return accum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xdec6
movl -0xc(%rbp), %eax
shll %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0xde9f
movl -0xc(%rbp), %eax
movl $0x3ff, %ecx            # imm = 0x3FF
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)