LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_mt_eq
int Pair_mt_eq(lua_State *L) {

  // Expected: stack = [self (p), other (q)]

  // Extract the pairs p, q from the stack.
  Pair *p = (Pair *)luaL_checkudata(L, 1, Pair_metatable);
  Pair *q = (Pair *)luaL_testudata(L, 2, Pair_metatable);

  // Push true or false onto the stack.
  if (q == NULL) {
    lua_pushboolean(L, 0);  // If q is not a Pair, return false.
  } else {
    lua_pushboolean(L, p->x == q->x && p->y == q->y);
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f7(%rip), %r15       # 0x1f095
pushq $0x1
popq %rsi
movq %r15, %rdx
callq 0x12fa2
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12f35
xorl %esi, %esi
testq %rax, %rax
je 0x1ece2
movsd (%r14), %xmm0
ucomisd (%rax), %xmm0
jne 0x1ece2
jp 0x1ece2
movsd 0x8(%rax), %xmm0
cmpeqsd 0x8(%r14), %xmm0
movq %xmm0, %rsi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x6386
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: luaopen_Pair
int luaopen_Pair(lua_State *L) {

  // The user may pass in values here,
  // but we'll ignore those values.
  lua_settop(L, 0);

    // stack = []

  // If this metatable already exists, the library is already
  // loaded.
  if (luaL_newmetatable(L, Pair_metatable)) {

    // stack = [mt]

    static struct luaL_Reg metamethods[] = {
      {"__index", Pair_mt_index},
      {"__add",   Pair_mt_add},
      {"__eq",    Pair_mt_eq},
      {"__mul",   Pair_mt_mul},
      {NULL, NULL}
    };
    luaL_setfuncs(L, metamethods, 0);
    lua_pop(L, 1);  // The table is saved in the Lua's registry.

    // stack = []
  }

  static struct luaL_Reg fns[] = {
    {"new", Pair_new},
    {NULL, NULL}
  };

  luaL_newlib(L, fns);  // Push a new table with fns key/vals.

    // stack = [Pair = {new = new}]

  return 1;  // Return the top item, the Pair table.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5b31
leaq 0x385(%rip), %rsi       # 0x1f095
movq %rbx, %rdi
callq 0x12ea0
testl %eax, %eax
je 0x1ed38
leaq 0x105ad(%rip), %rsi     # 0x2f2d0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13c52
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5b31
movsd 0x1fe0(%rip), %xmm0     # 0x20d20
movl $0x88, %esi
movq %rbx, %rdi
callq 0x13f6d
pushq $0x1
popq %r14
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x665a
leaq 0x105bb(%rip), %rsi     # 0x2f320
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13c52
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/macro11.c
// Function: print_version
static void print_version(
    FILE *strm)
{
    fprintf(strm, "macro11 - portable MACRO11 assembler for DEC PDP-11\n");
    fprintf(strm, "  Version %s\n", VERSIONSTR);
    fprintf(strm, "  Copyright 2001 Richard Krehbiel,\n");
    fprintf(strm, "  modified 2009 by Joerg Hoppe,\n");
    fprintf(strm, "  modified 2015 by Olaf 'Rhialto' Seibert.\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb3ca(%rip), %rdi      # 0xe2a5
pushq $0x34
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x22d0
leaq 0xb3e6(%rip), %rsi      # 0xe2da
leaq 0xb3ed(%rip), %rdx      # 0xe2e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
leaq 0xb3ef(%rip), %rdi      # 0xe2fb
pushq $0x23
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x22d0
leaq 0xb3fe(%rip), %rdi      # 0xe31f
pushq $0x20
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x22d0
leaq 0xb40a(%rip), %rdi      # 0xe340
pushq $0x2b
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/macro11.c
// Function: enable_tf
static void enable_tf(
    char *opt,
    int tf)
{
    if (strcmp(opt, "AMA") == 0)
        enabl_ama = tf;
    else if (strcmp(opt, "GBL") == 0)
        enabl_gbl = tf;
    else if (strcmp(opt, "ME") == 0)
        list_me = tf;
    else if (strcmp(opt, "BEX") == 0)
        list_bex = tf;
    else if (strcmp(opt, "MD") == 0)
        list_md = tf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xb97d(%rip), %rsi      # 0xe8d8
callq 0x21d0
testl %eax, %eax
je 0x2fbe
leaq 0xba12(%rip), %rsi      # 0xe97d
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
je 0x2fc7
movb (%r14), %bpl
cmpb $0x4d, %bpl
jne 0x2f8e
cmpb $0x45, 0x1(%r14)
jne 0x2f8e
cmpb $0x0, 0x2(%r14)
je 0x2fd9
leaq 0xb3d7(%rip), %rsi      # 0xe36c
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
je 0x2fd0
cmpb $0x4d, %bpl
jne 0x2fe2
cmpb $0x44, 0x1(%r14)
jne 0x2fe2
cmpb $0x0, 0x2(%r14)
jne 0x2fe2
leaq 0x12ab8(%rip), %rax     # 0x15a74
jmp 0x2fe0
leaq 0x12bb7(%rip), %rax     # 0x15b7c
jmp 0x2fe0
leaq 0x121da(%rip), %rax     # 0x151a8
jmp 0x2fe0
leaq 0x12aa5(%rip), %rax     # 0x15a7c
jmp 0x2fe0
leaq 0x12a98(%rip), %rax     # 0x15a78
movl %ebx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/macro11.c
// Function: append_env
static void append_env(
    char *envname,
    char *value)
{
    char           *env = getenv(envname);
    char           *temp;

    if (env == NULL)
        env = "";

    temp = memcheck(malloc(strlen(envname) +
                           1 +
                           strlen(env) +
                           1 +
                           strlen(value) +
                           1));
    strcpy(temp, envname);
    strcat(temp, "=");
    strcat(temp, env);
    strcat(temp, PATHSEP);
    strcat(temp, value);
    putenv(temp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2040
testq %rax, %rax
leaq 0xcb78(%rip), %r14      # 0xfb7d
cmovneq %rax, %r14
movq %r15, %rdi
callq 0x20e0
movq %rax, %r12
movq %r14, %rdi
callq 0x20e0
movq %rax, %r13
movq %rbx, %rdi
callq 0x20e0
addq %r12, %r13
leaq (%rax,%r13), %rdi
addq $0x3, %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x2090
movq %r12, %rdi
callq 0x20e0
movw $0x3d, (%r12,%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0x22a0
movq %r12, %rdi
callq 0x20e0
movw $0x3a, (%r12,%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x22a0
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21c0
nop
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble.c
// Function: get_next_lsb
int get_next_lsb(
    void)
{
    if (lsb_used) {
        lsb_used = 0;
        if (enabl_debug && lstfile) {
            fprintf(lstfile, "get_next_lsb: lsb: %d becomes %d (= next_lsb)\n", lsb, next_lsb);
        }
        return next_lsb++;
    } else {
        if (enabl_debug && lstfile) {
            fprintf(lstfile, "get_next_lsb: lsb: stays %d\n", lsb);
        }
        return lsb;
    }
}

// Assembly:
pushq %rax
leaq 0x12ad0(%rip), %rax     # 0x15b6c
cmpl $0x0, (%rax)
je 0x30f8
andl $0x0, (%rax)
leaq 0x12acd(%rip), %rax     # 0x15b78
cmpl $0x0, (%rax)
setne %al
leaq 0x145a8(%rip), %rcx     # 0x17660
movq (%rcx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x30e8
leaq 0x12a99(%rip), %rax     # 0x15b68
movl (%rax), %edx
leaq 0x12a98(%rip), %rax     # 0x15b70
movl (%rax), %ecx
leaq 0xba6f(%rip), %rsi      # 0xeb50
xorl %eax, %eax
callq 0x21e0
leaq 0x12a81(%rip), %rcx     # 0x15b70
movl (%rcx), %eax
leal 0x1(%rax), %edx
movl %edx, (%rcx)
jmp 0x313c
leaq 0x12a79(%rip), %rax     # 0x15b78
cmpl $0x0, (%rax)
setne %al
leaq 0x14554(%rip), %rcx     # 0x17660
movq (%rcx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3133
leaq 0x12a45(%rip), %rax     # 0x15b68
movl (%rax), %edx
leaq 0xba53(%rip), %rsi      # 0xeb7f
xorl %eax, %eax
callq 0x21e0
leaq 0x12a2e(%rip), %rax     # 0x15b68
movl (%rax), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble.c
// Function: assemble_stack
int assemble_stack(
    STACK *stack,
    TEXT_RLD *tr)
{
    int             res;
    int             errcount = 0;

    while ((res = assemble(stack, tr)) >= 0) {
        list_flush();
        if (res == 0)
            errcount++;                   /* Count an error */
    }

    return errcount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x317a
testl %eax, %eax
js 0x316d
movl %eax, %r15d
callq 0x7469
cmpl $0x1, %r15d
adcl $0x0, %ebp
jmp 0x314d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: change_dot
void change_dot(
    TEXT_RLD *tr,
    int size)
{
    if (size > 0) {
        if (last_dot_section != current_pc->section) {
            text_define_location(tr, current_pc->section->label, &current_pc->value);
            last_dot_section = current_pc->section;
            last_dot_addr = current_pc->value;
        }
        if (last_dot_addr != current_pc->value) {
            text_modify_location(tr, &current_pc->value);
            last_dot_addr = current_pc->value;
        }

        /* Update for next time */
        last_dot_addr += size;
    }

    if (DOT + size > current_pc->section->size)
        current_pc->section->size = DOT + size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
leaq 0x11ced(%rip), %r14     # 0x17648
movq (%r14), %rax
testl %esi, %esi
jle 0x59b0
leaq 0x11cef(%rip), %r15     # 0x17658
movq 0x18(%rax), %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, (%r15)
je 0x598a
movq (%rcx), %rsi
callq 0xc066
movq (%r14), %rax
movq 0x18(%rax), %rcx
movq %rcx, (%r15)
jmp 0x59a2
leaq 0x11cbf(%rip), %rsi     # 0x17650
movl (%rdx), %ecx
cmpl %ecx, (%rsi)
je 0x59a5
movq %rdx, %rsi
callq 0xc121
movq (%r14), %rax
movl 0x8(%rax), %ecx
addl %ebx, %ecx
leaq 0x11ca2(%rip), %rdx     # 0x17650
movl %ecx, (%rdx)
addl 0x8(%rax), %ebx
movq 0x18(%rax), %rax
cmpl 0x14(%rax), %ebx
jbe 0x59bf
movl %ebx, 0x14(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: store_limits
int store_limits(
    STREAM *str,
    TEXT_RLD *tr)
{
    change_dot(tr, 4);
    list_word(str, DOT, 0, 2, "");
    list_word(str, DOT + 2, 0, 2, "");
    return text_limits(tr, &DOT);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x594d
leaq 0x11c0a(%rip), %r12     # 0x17648
movq (%r12), %rax
movl 0x8(%rax), %esi
leaq 0xa131(%rip), %r15      # 0xfb7d
pushq $0x2
popq %rbp
movq %r14, %rdi
xorl %edx, %edx
movl %ebp, %ecx
movq %r15, %r8
callq 0x7517
movq (%r12), %rax
movl 0x8(%rax), %esi
addl $0x2, %esi
movq %r14, %rdi
xorl %edx, %edx
movl %ebp, %ecx
movq %r15, %r8
callq 0x7517
movq (%r12), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc19c
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: implicit_gbl
void implicit_gbl(
    EX_TREE *value)
{
    if (pass)
        return;                        /* Only do this in first pass */

    if (!enabl_gbl)
        return;                        /* Option not enabled, don't do it. */

    switch (value->type) {
    case EX_UNDEFINED_SYM:
        {
            if (!(value->data.symbol->flags & SYMBOLFLAG_LOCAL)) {      /* Unless it's a
                                                                           local symbol, */
                add_sym(value->data.symbol->label, 0, SYMBOLFLAG_GLOBAL, &absolute_section, &implicit_st);
            }
        }
        break;
    case EX_LIT:
    case EX_SYM:
    case EX_TEMP_SYM: // Impossible on this pass
        return;
    case EX_ADD:
    case EX_SUB:
    case EX_MUL:
    case EX_DIV:
    case EX_AND:
    case EX_OR:
        implicit_gbl(value->data.child.right);
        /* falls into... */
    case EX_COM:
    case EX_NEG:
        implicit_gbl(value->data.child.left);
        break;
    case EX_ERR:
        if (value->data.child.left)
            implicit_gbl(value->data.child.left);
        break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10079(%rip), %r14     # 0x15b60
movl (%r14), %ecx
leaq 0xf6b7(%rip), %r15      # 0x151a8
movl (%r15), %eax
leaq 0x96d1(%rip), %r12      # 0xf1cc
testl %ecx, %ecx
sete %cl
testb $0x1, %cl
je 0x5b72
testl %eax, %eax
je 0x5b72
movl (%rbx), %ecx
addl $-0x3, %ecx
cmpl $0xa, %ecx
ja 0x5b72
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movq 0x10(%rbx), %rbx
movb $0x1, %cl
testq %rbx, %rbx
jne 0x5b00
jmp 0x5b72
movq 0x18(%rbx), %rdi
callq 0x5ad5
movl (%r14), %ecx
movl (%r15), %eax
jmp 0x5b3c
xorl %ecx, %ecx
movq 0x10(%rbx), %rbx
jmp 0x5afb
movq 0x10(%rbx), %rax
testb $0x20, 0x10(%rax)
jne 0x5b72
movq (%rax), %rdi
leaq 0xf6da(%rip), %rcx      # 0x15230
leaq 0x19b53(%rip), %r8      # 0x1f6b0
pushq $0x2
popq %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x97f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: migrate_implicit
void migrate_implicit(
    void)
{
    SYMBOL_ITER     iter;
    SYMBOL         *isym,
                   *sym;

    for (isym = first_sym(&implicit_st, &iter); isym != NULL; isym = next_sym(&implicit_st, &iter)) {
        sym = lookup_sym(isym->label, &symbol_st);
        if (sym) {
            continue;                  // It's already in there.  Great.
        }
        isym->flags |= SYMBOLFLAG_IMPLICIT_GLOBAL;
        sym = add_sym(isym->label, isym->value, isym->flags, isym->section, &symbol_st);
        // Just one other thing - migrate the stmtno
        sym->stmtno = isym->stmtno;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x19b20(%rip), %rbx     # 0x1f6b0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97be
movq %rax, %r12
leaq 0x11ae6(%rip), %r15     # 0x17690
testq %r12, %r12
je 0x5bfb
movq (%r12), %rdi
movq %r15, %rsi
callq 0x974c
testq %rax, %rax
jne 0x5beb
movl 0x10(%r12), %edx
orl $0x40, %edx
movl %edx, 0x10(%r12)
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq 0x18(%r12), %rcx
movq %r15, %r8
callq 0x97f3
movl 0xc(%r12), %ecx
movl %ecx, 0xc(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9789
movq %rax, %r12
jmp 0x5baa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: express_sym_offset
int express_sym_offset(
    EX_TREE *value,
    SYMBOL **sym,
    unsigned *offset)
{
    implicit_gbl(value);               /* Translate tree's undefined syms
                                          into global syms */

    /* Internally relocatable symbols will have been summed down into
       EX_TEMP_SYM's. */

    if (value->type == EX_SYM || value->type == EX_TEMP_SYM) {
        *sym = value->data.symbol;
        *offset = 0;
        return 1;
    }

    /* What remains is external symbols. */

    if (value->type == EX_ADD) {
        EX_TREE        *left = value->data.child.left;
        EX_TREE        *right = value->data.child.right;

        if ((left->type != EX_SYM && left->type != EX_UNDEFINED_SYM) || right->type != EX_LIT)
            return 0;                  /* Failed. */
        *sym = left->data.symbol;
        *offset = right->data.lit;
        return 1;
    }

    if (value->type == EX_SUB) {
        EX_TREE        *left = value->data.child.left;
        EX_TREE        *right = value->data.child.right;

        if ((left->type != EX_SYM && left->type != EX_UNDEFINED_SYM) || right->type != EX_LIT)
            return 0;                  /* Failed. */
        *sym = left->data.symbol;
        *offset = (unsigned) -(int) (right->data.lit);
        return 1;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x5ad5
movl (%r15), %ecx
xorl %eax, %eax
addl $-0x2, %ecx
cmpl $0x7, %ecx
ja 0x5c45
leaq 0x95ca(%rip), %rdx      # 0xf1f8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%r15), %rax
movq %rax, (%r14)
xorl %eax, %eax
movl %eax, (%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%r15), %rcx
movl (%rcx), %edx
andl $-0x2, %edx
cmpl $0x2, %edx
jne 0x5c45
movq 0x18(%r15), %rdx
cmpl $0x1, (%rdx)
jne 0x5c45
movq 0x10(%rcx), %rax
movq %rax, (%r14)
xorl %eax, %eax
subl 0x10(%rdx), %eax
jmp 0x5c40
movq 0x10(%r15), %rcx
movl (%rcx), %edx
andl $-0x2, %edx
cmpl $0x2, %edx
jne 0x5c45
movq 0x18(%r15), %rdx
cmpl $0x1, (%rdx)
jne 0x5c45
movq 0x10(%rcx), %rax
movq %rax, (%r14)
movl 0x10(%rdx), %eax
jmp 0x5c40
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: store_complex
static void store_complex(
    STREAM *refstr,
    TEXT_RLD *tr,
    int size,
    EX_TREE *value)
{
    TEXT_COMPLEX    tx;

    change_dot(tr, size);              /* About to store - update DOT */

    implicit_gbl(value);               /* Turn undefined symbols into globals */

    text_complex_begin(&tx);           /* Open complex expression */

    if (!complex_tree(&tx, value)) {   /* Translate */
        report(refstr, "Invalid expression\n");
        store_word(refstr, tr, size, 0);
    } else {
        list_word(refstr, DOT, 0, size, "C");
        text_complex_commit(tr, &DOT, size, &tx, 0);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
callq 0x594d
movq %r12, %rdi
callq 0x5ad5
leaq 0xc(%rsp), %r13
movq %r13, %rdi
callq 0xc44b
movq %r13, %rdi
movq %r12, %rsi
callq 0x5c93
testl %eax, %eax
je 0x62fe
leaq 0x11380(%rip), %r12     # 0x17648
movq (%r12), %rax
movl 0x8(%rax), %esi
leaq 0x96a7(%rip), %r8       # 0xf97d
movq %r15, %rdi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x7517
movq (%r12), %rsi
addq $0x8, %rsi
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %edx
xorl %r8d, %r8d
callq 0xc626
jmp 0x631e
leaq 0x8ff5(%rip), %rsi      # 0xf2fa
movq %r15, %rdi
xorl %eax, %eax
callq 0x7668
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x59c5
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: eval_defined
int eval_defined(
    EX_TREE *value)
{
    switch (value->type) {
    case EX_LIT:
        return 1;
    case EX_SYM:
        return 1;
    case EX_UNDEFINED_SYM:
        return 0;
    case EX_AND:
        return eval_defined(value->data.child.left) && eval_defined(value->data.child.right);
    case EX_OR:
        return eval_defined(value->data.child.left) || eval_defined(value->data.child.right);
    default:
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
xorl %ebp, %ebp
movl (%rbx), %eax
cmpl $0xc, %eax
je 0x6357
cmpl $0xd, %eax
jne 0x636a
movq 0x10(%rbx), %rdi
callq 0x632f
testl %eax, %eax
je 0x6364
jmp 0x6371
movq 0x10(%rbx), %rdi
callq 0x632f
testl %eax, %eax
je 0x6374
movq 0x18(%rbx), %rbx
jmp 0x633c
decl %eax
cmpl $0x2, %eax
jae 0x6374
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: eval_undefined
int eval_undefined(
    EX_TREE *value)
{
    switch (value->type) {
    case EX_UNDEFINED_SYM:
        return 1;
    case EX_SYM:
        return 0;
    case EX_AND:
        return eval_undefined(value->data.child.left) && eval_undefined(value->data.child.right);
    case EX_OR:
        return eval_undefined(value->data.child.left) || eval_undefined(value->data.child.right);
    default:
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
xorl %ebp, %ebp
movl (%rbx), %eax
cmpl $0xc, %eax
je 0x63a3
cmpl $0xd, %eax
jne 0x63b6
movq 0x10(%rbx), %rdi
callq 0x637b
testl %eax, %eax
je 0x63b0
jmp 0x63bb
movq 0x10(%rbx), %rdi
callq 0x637b
testl %eax, %eax
je 0x63be
movq 0x18(%rbx), %rbx
jmp 0x6388
cmpl $0x3, %eax
jne 0x63be
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: push_cond
void push_cond(
    int ok,
    STREAM *str)
{
    last_cond++;
    assert(last_cond < MAX_CONDS);
    conds[last_cond].ok = ok;
    conds[last_cond].file = memcheck(strdup(str->name));
    conds[last_cond].line = str->line;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x110df(%rip), %r14     # 0x174b0
movslq (%r14), %rcx
leaq 0x1(%rcx), %rax
movl %eax, (%r14)
cmpq $0xff, %rcx
jge 0x6421
movq %rsi, %rbx
imulq $0x18, %rax, %rax
leaq 0xf8be(%rip), %r15      # 0x15cb0
movl %edi, (%r15,%rax)
movq 0x8(%rsi), %rdi
callq 0x22e0
movq %rax, %rdi
callq 0xcd2d
movslq (%r14), %rcx
imulq $0x18, %rcx, %rcx
movq %rax, 0x8(%r15,%rcx)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r15,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8e24(%rip), %rdi      # 0xf24c
leaq 0x8e33(%rip), %rsi      # 0xf262
leaq 0x8e3b(%rip), %rcx      # 0xf271
movl $0x233, %edx            # imm = 0x233
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: store_value
void store_value(
    STACK *stack,
    TEXT_RLD *tr,
    int size,
    EX_TREE *value)
{
    SYMBOL         *sym;
    unsigned        offset;

    implicit_gbl(value);               /* turn undefined symbols into globals */

    if (value->type == EX_LIT) {
        store_word(stack->top, tr, size, value->data.lit);
    } else if (!express_sym_offset(value, &sym, &offset)) {
        store_complex(stack->top, tr, size, value);
    } else {
        if ((sym->flags & (SYMBOLFLAG_GLOBAL | SYMBOLFLAG_DEFINITION)) == SYMBOLFLAG_GLOBAL) {
            store_global_offset_word(stack->top, tr, size, sym->value + offset, sym->label);
        } else if (sym->section != current_pc->section) {
            store_psect_offset_word(stack->top, tr, size, sym->value + offset, sym->section->label);
        } else {
            store_internal_word(stack->top, tr, size, sym->value + offset);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rdi
callq 0x5ad5
cmpl $0x1, (%r12)
jne 0x64e2
movq (%r15), %rdi
movl 0x10(%r12), %ecx
movq %r14, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x59c5
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
callq 0x5c07
testl %eax, %eax
je 0x652a
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
andl $0xa, %ecx
cmpl $0x2, %ecx
jne 0x6545
movq (%r15), %rdi
movl 0xc(%rsp), %ecx
addl 0x8(%rax), %ecx
movq (%rax), %r8
movq %r14, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6149
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6278
movq 0x18(%rax), %rdx
leaq 0x110f8(%rip), %rsi     # 0x17648
movl 0xc(%rsp), %ecx
addl 0x8(%rax), %ecx
movq (%rsi), %rax
movq (%r15), %rdi
cmpq 0x18(%rax), %rdx
je 0x657b
movq (%rdx), %r8
movq %r14, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x620d
movq %r14, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x61b4
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: do_word
int do_word(
    STACK *stack,
    TEXT_RLD *tr,
    char *cp,
    int size)
{
    int comma;

    if (size == 2 && (DOT & 1)) {
        report(stack->top, ".WORD on odd boundary\n");
        store_word(stack->top, tr, 1, 0);       /* Align it */
    }

    cp = skipwhite(cp);

    do {
        if (cp[0] == ',') {
            /* Empty expressions count as 0 */
            store_word(stack->top, tr, size, 0);
        } else {
            EX_TREE        *value = parse_expr(cp, 0);

            if (value->cp > cp) {
                store_value(stack, tr, size, value);

                cp = value->cp;
            } else {
                report(stack->top, "Invalid expression in .WORD\n");
                cp = "";                /* force loop to end */
            }

            free_tree(value);
        }
    } while (cp = skipdelim_comma(cp, &comma), !EOL(*cp));

    if (comma) {
        /* Trailing empty expressions count as 0 */
        store_word(stack->top, tr, size, 0);
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x2, %ecx
jne 0x65dc
leaq 0x11096(%rip), %rax     # 0x17648
movq (%rax), %rax
testb $0x1, 0x8(%rax)
je 0x65dc
movq (%r15), %rdi
leaq 0x8965(%rip), %rsi      # 0xef2a
xorl %eax, %eax
callq 0x7668
movq (%r15), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x59c5
movq %r12, %rdi
callq 0x8234
movq %rax, %rbp
movb (%rax), %al
leaq 0x4(%rsp), %r12
cmpb $0x2c, %al
jne 0x6603
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x59c5
jmp 0x664c
movq %rbp, %rdi
xorl %esi, %esi
callq 0x8a04
movq %rax, %r13
cmpq %rbp, 0x8(%rax)
jbe 0x662c
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0x64a0
movq 0x8(%r13), %rbp
jmp 0x6644
movq (%r15), %rdi
leaq 0x8c59(%rip), %rsi      # 0xf28f
xorl %eax, %eax
callq 0x7668
leaq 0x9539(%rip), %rbp      # 0xfb7d
movq %r13, %rdi
callq 0x6add
movq %rbp, %rdi
movq %r12, %rsi
callq 0x8263
movq %rax, %rbp
movzbl (%rax), %eax
cmpq $0x3b, %rax
ja 0x65ee
movabsq $0x800000000000401, %rcx # imm = 0x800000000000401
btq %rax, %rcx
jae 0x65ee
cmpl $0x0, 0x4(%rsp)
je 0x668d
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x59c5
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/assemble_aux.c
// Function: check_branch
int check_branch(
    STACK *stack,
    unsigned offset,
    int min,
    int max)
{
    int             s_offset;

    /* Sign-extend */
    if (offset & 0100000)
        s_offset = offset | ~0177777;
    else
        s_offset = offset & 077777;
    if (s_offset > max || s_offset < min) {
        char            temp[16];

        /* printf can't do signed octal. */
        my_ltoa(s_offset, temp, 8);
        report(stack->top, "Branch target out of range (distance=%s)\n", temp);
        return 0;
    }
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, %edi
orl $0xffff0000, %edi       # imm = 0xFFFF0000
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
testw %si, %si
cmovsl %edi, %eax
cmpl %ecx, %eax
setle %cl
cmpl %edx, %eax
setge %dl
testb %dl, %cl
jne 0x66f5
movslq %eax, %rdi
movq %rsp, %r14
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0xcc30
movq (%rbx), %rdi
leaq 0x8bc5(%rip), %rsi      # 0xf2ac
xorl %ebx, %ebx
movq %r14, %rdx
xorl %eax, %eax
callq 0x7668
jmp 0x66f8
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6b8e
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
movq %rax, %r14
movq (%rbx), %rdi
callq 0x22e0
movq %rax, %rdi
callq 0xcd2d
movq %rax, (%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
andq $0x0, 0x20(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x6b91
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
movq %rax, %r12
movq %r15, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0xcd2d
movq %rax, (%r12)
andl $0x0, 0x10(%r12)
leaq 0xe880(%rip), %rax      # 0x15b64
movl (%rax), %eax
movl %eax, 0xc(%r12)
andq $0x0, 0x20(%r12)
movq %r14, 0x18(%r12)
movl %ebx, 0x8(%r12)
callq 0x6c26
movl $0x4, (%rax)
movq %r12, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0x6c26
movl %ebp, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6c26
movq %rbx, 0x8(%rax)
movl $0x7, (%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x743a
testl %eax, %eax
je 0x742e
leaq 0x87ea(%rip), %rsi      # 0xfb7c
movq %r14, %rdi
callq 0x2180
movq %rax, %r15
movq 0x102cc(%rip), %rdi     # 0x17670
callq 0x2050
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
movq %rax, %r12
movq %rax, 0x102a9(%rip)     # 0x17670
movslq %r15d, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2220
movb $0x0, (%r12,%r15)
movq 0x10294(%rip), %rdi     # 0x17678
testq %rdi, %rdi
jne 0x7403
pushq $0x39
popq %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
movq %rax, %rdi
movq %rax, 0x10275(%rip)     # 0x17678
movl 0x10(%rbx), %r9d
leaq 0x8069(%rip), %rsi      # 0xf477
leaq 0x8768(%rip), %rcx      # 0xfb7d
pushq $0x2
popq %rdx
pushq $0x6
popq %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpq $0x0, 0x1021c(%rip)     # 0x17660
je 0x745b
leaq 0xe713(%rip), %rcx      # 0x15b60
cmpl $0x0, (%rcx)
jg 0x745c
cmpl $0x0, 0x1020f(%rip)     # 0x17668
jne 0x745c
retq
xorl %eax, %eax
cmpl $0x0, 0xe61b(%rip)      # 0x15a80
setg %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x743a
testl %eax, %eax
je 0x74cb
movq 0x101fe(%rip), %rdi     # 0x17678
pushq $0x28
popq %rsi
callq 0xcdb1
movq 0x101ef(%rip), %rdi     # 0x17678
movq 0x101d0(%rip), %rsi     # 0x17660
callq 0x2130
movq 0x101d4(%rip), %rdi     # 0x17670
movq 0x101bd(%rip), %rsi     # 0x17660
callq 0x2130
movq 0x101b1(%rip), %rsi     # 0x17660
pushq $0xa
popq %rdi
callq 0x2170
movq 0x101b2(%rip), %rax     # 0x17670
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x101af(%rip), %rax     # 0x17678
movb %cl, (%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x743a
testl %eax, %eax
je 0x750f
movq 0x10192(%rip), %rdi     # 0x17678
movb $0x0, (%rdi)
movl 0x10(%r14), %r9d
movzwl %bx, %eax
movl %eax, (%rsp)
leaq 0x7f84(%rip), %rsi      # 0xf47e
leaq 0x867c(%rip), %rcx      # 0xfb7d
pushq $0x2
popq %rdx
pushq $0x6
popq %r8
xorl %eax, %eax
callq 0x22b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
movq 0x100cd(%rip), %r14     # 0x17678
movq %r14, %rdi
callq 0x20e0
cmpq $0x28, %rax
jb 0x75ef
callq 0x7469
movq 0x100ab(%rip), %rax     # 0x17670
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x100a8(%rip), %rdi     # 0x17678
movb %cl, (%rdi)
leaq 0x7ee5(%rip), %rsi      # 0xf4be
leaq 0x859d(%rip), %rcx      # 0xfb7d
pushq $0x8
popq %rdx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x22b0
jmp 0x761b
cmpq $0x8, %rax
ja 0x7633
movl 0x10(%r15), %r9d
movl %ebx, (%rsp)
leaq 0x7ec5(%rip), %rsi      # 0xf4c8
leaq 0x8573(%rip), %rcx      # 0xfb7d
pushq $0x2
popq %rdx
pushq $0x6
popq %r8
movq %r14, %rdi
xorl %eax, %eax
callq 0x22b0
movq 0x10056(%rip), %rdi     # 0x17678
pushq $0x10
popq %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xcdb1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x76cb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0xe48e(%rip), %rax      # 0x15b60
cmpl $0x0, (%rax)
jne 0x76f2
cmpl $0x2, 0xff8a(%rip)      # 0x17668
jge 0x76f2
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rdi, %rdi
jne 0x7702
xorl %ebp, %ebp
leaq 0x8451(%rip), %r14      # 0xfb51
jmp 0x7709
movq 0x8(%rdi), %r14
movl 0x10(%rdi), %ebp
movq 0xd8e8(%rip), %r15      # 0x14ff8
movq (%r15), %rdi
leaq 0x7d93(%rip), %rsi      # 0xf4ad
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x21e0
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x110(%rsp), %r12
movq %r12, 0x8(%rdx)
leaq 0x20(%rsp), %r13
movq %r13, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2280
movq 0xff03(%rip), %rdi      # 0x17660
testq %rdi, %rdi
je 0x76e0
leaq 0x7d40(%rip), %rsi      # 0xf4ad
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x21e0
movq %rsp, %rdx
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %r12, 0x8(%rdx)
movq %r13, 0x10(%rdx)
movq 0xfec8(%rip), %rdi      # 0x17660
movq %rbx, %rsi
callq 0x2280
jmp 0x76e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
pushq $0x38
popq %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
movq %rax, %r14
movq 0x8(%r13), %rdi
callq 0x20e0
leaq 0x20(%rax), %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
movq %rax, %rbp
movq 0x8(%r13), %rdx
movl 0x10(%r13), %ecx
movq (%r12), %r8
leaq 0x7cbf(%rip), %rsi      # 0xf4d5
movq %rax, %rdi
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xc995
movq %rbp, %rdi
callq 0x2050
leaq 0xe24b(%rip), %rax      # 0x15a88
movq %rax, (%r14)
movl %ebx, 0x30(%r14)
leaq 0xfc65(%rip), %rax      # 0x174b0
movl (%rax), %eax
movl %eax, 0x34(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x7b40(%rip), %rsi      # 0xf525
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
leaq 0x28(%r14), %r12
pushq $0x20
popq %rbp
pushq $0x3d
popq %r15
movq (%r12), %r12
testq %r12, %r12
je 0x7a3c
movq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0x2130
cmpq $0x0, 0x18(%r12)
je 0x7a30
movl %r15d, %edi
movq %rbx, %rsi
callq 0x2170
movq 0x18(%r12), %rdi
movq %rbx, %rsi
callq 0x2130
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2170
jmp 0x79fa
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2170
movq 0x30(%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x2130
leaq 0x7ad3(%rip), %rdi      # 0xf530
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2130
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x2050
movq 0x28(%rbx), %rdi
callq 0x8177
movq %rbx, %rdi
popq %rbx
jmp 0x96f7
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
andl $0x0, 0x10(%rax)
movq %rbx, (%rax)
leaq 0xdedf(%rip), %rcx      # 0x15b64
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
andq $0x0, 0x20(%rax)
leaq 0xd57a(%rip), %rcx      # 0x15210
movq %rcx, 0x18(%rax)
andl $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x20
popq %rdi
callq 0x2230
movq %rax, %rdi
callq 0xcd2d
andl $0x0, 0x8(%rax)
andq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/macros.c
// Function: subst_args
BUFFER         *subst_args(
    BUFFER *text,
    ARG *args)
{
    char           *in;
    char           *begin;
    BUFFER         *gb;
    char           *label;
    ARG            *arg;

    gb = new_buffer();

    /* Blindly look for argument symbols in the input. */
    /* Don't worry about quotes or comments. */

    for (begin = in = text->buffer; in < text->buffer + text->length;) {
        char           *next;

        if (issym((unsigned char)*in)) {
            label = get_symbol(in, &next, NULL);
            if (label) {
                if ((arg = find_arg(args, label))) {
                    /* An apostrophe may appear before or after the symbol. */
                    /* In either case, remove it from the expansion. */

                    if (in > begin && in[-1] == '\'')
                        in--;          /* Don't copy it. */
                    if (*next == '\'')
                        next++;

                    /* Copy prior characters */
                    buffer_appendn(gb, begin, (int) (in - begin));
                    /* Copy replacement string */
                    buffer_append_line(gb, arg->value);
                    in = begin = next;
                    --in;              /* prepare for subsequent increment */
                }
                free(label);
                in = next;
            } else
                in++;
        } else
            in++;
    }

    /* Append the rest of the text */
    buffer_appendn(gb, begin, (int) (in - begin));

    return gb;                         /* Done. */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
callq 0xc798
movq %rax, %rbx
movq (%r15), %rax
movq %rax, %r13
movq %rax, %rbp
movslq 0xc(%r15), %rcx
addq %rax, %rcx
cmpq %rcx, %rbp
jae 0x7dd0
callq 0x2300
movq (%rax), %rcx
movzbl (%rbp), %eax
movzwl (%rcx,%rax,2), %ecx
testw $0xc00, %cx             # imm = 0xC00
je 0x7d9e
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x8597
testq %rax, %rax
je 0x7dc5
movq %rax, %r12
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x7df2
testq %rax, %rax
je 0x7d8f
movq %rax, %r14
cmpq %r13, %rbp
jbe 0x7d5c
leaq -0x1(%rbp), %rax
cmpb $0x27, -0x1(%rbp)
cmoveq %rax, %rbp
movq 0x8(%rsp), %rax
cmpb $0x27, (%rax)
jne 0x7d6e
incq %rax
movq %rax, 0x8(%rsp)
subl %r13d, %ebp
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0xc823
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xc898
movq 0x8(%rsp), %r13
movq %r12, %rdi
callq 0x2050
movq 0x8(%rsp), %rbp
jmp 0x7dc8
cmpl $0x24, %eax
je 0x7d1b
cmpl $0x2e, %eax
je 0x7d1b
cmpl $0x5f, %eax
jne 0x7dc5
leaq 0xf8c4(%rip), %rax      # 0x17680
cmpl $0x0, (%rax)
jne 0x7d1b
incq %rbp
movq (%r15), %rax
jmp 0x7cf0
subl %r13d, %ebp
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0xc823
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
xorl %esi, %esi
callq 0x8a04
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x7e4b
movzwl 0x10(%r14), %r15d
jmp 0x7e5f
leaq 0x7717(%rip), %rsi      # 0xf569
xorl %r15d, %r15d
movq %r12, %rdi
xorl %eax, %eax
callq 0x7668
movq %r14, %rdi
callq 0x6add
leaq 0xd332(%rip), %rax      # 0x151a0
movl (%rax), %edx
leaq 0xe(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xcbe4
movq %rbx, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0xcd2d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x5c, (%rsi)
jne 0x7ec7
pushq %rbx
movq %rdi, %rbx
incq %rsi
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8286
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x7e21
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x8286