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

  // Extract the x, y data from the stack.
  luaL_checktype(L, 2, LUA_TTABLE);
      // stack = [self, p]
  lua_rawgeti(L, 2, 1);  // 2, 1 = idx in stack, idx in table
      // stack = [self, p, p[1]]
  lua_rawgeti(L, 2, 2);
      // stack = [self, p, p[1], p[2]]
  lua_Number x = lua_tonumber(L, -2);  // p[1]
  lua_Number y = lua_tonumber(L, -1);  // p[2]
  lua_settop(L, 0);
      // stack = []

  // Create a Pair instance and set its metatable.
  Pair *pair = (Pair *)lua_newuserdata(L, sizeof(Pair));
      // stack = [pair]
  luaL_getmetatable(L, Pair_metatable);
      // stack = [pair, mt]
  lua_setmetatable(L, 1);
      // stack = [pair]

  // Set up the C data.
  pair->x = x;
  pair->y = y;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x2, %esi
movl $0x5, %edx
callq 0x15039
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6970
movl $0x2, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6970
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
xorl %edx, %edx
callq 0x628e
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x628e
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d4d
movl $0x10, %esi
movq %rbx, %rdi
callq 0x73bd
movq %rax, %r14
leaq 0x8ff(%rip), %rdx       # 0x2208d
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6895
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6e85
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%r14)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: push_new_pair
void push_new_pair(lua_State *L, lua_Number x, lua_Number y) {

  // Clear the stack.
  lua_settop(L, 0);
    // stack = []

  // Set up the new resulting Pair instance.
  lua_newtable(L);
    // stack = [t (the new table)]
  lua_pushnumber(L, x);
    // stack = [t, x]
  lua_rawseti(L, -2, 1);  // t[1] = x
    // stack = [t]
  lua_pushnumber(L, y);
    // stack = [t, y]
  lua_rawseti(L, -2, 2);  // t[2] = y
    // stack = [t]
  lua_pushvalue(L, -1);
    // stack = [t, t]
  Pair_new(L);
    // stack = [new Pair from t]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, -0x18(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5d4d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x69fb
movq %rbx, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x64e1
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6db0
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x64e1
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6db0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x606b
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x21704
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_mt_index
int Pair_mt_index(lua_State *L) {

  // Expected: stack = [self, key]
  Pair *pair = (Pair *)luaL_checkudata(L, 1, Pair_metatable);

  // Find the key value as either 1 (x) or 2 (y).
  int key = 0;
  int t = lua_type(L, 2);
  if (t == LUA_TNUMBER) {
    int ok;
    key = (int)lua_tointegerx(L, 2, &ok);
    if (!ok || (key != 1 && key != 2)) key = 0;
  } else if (t == LUA_TSTRING) {
    const char *str_key = lua_tostring(L, 2);
    if (strcmp(str_key, "x") == 0) key = 1;
    if (strcmp(str_key, "y") == 0) key = 2;
  }

  // Push the value.
  if (key) {
    lua_pushnumber(L, key == 1 ? pair->x : pair->y);
  } else {
    lua_pushnil(L);
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x82c(%rip), %rdx       # 0x2208d
movl $0x1, %esi
callq 0x14e5d
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x608f
cmpl $0x4, %eax
je 0x218af
cmpl $0x3, %eax
jne 0x218e8
leaq -0x1c(%rbp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x62e1
cmpl $0x0, (%r15)
sete %cl
leal -0x3(%rax), %edx
cmpl $-0x2, %edx
setb %dl
orb %cl, %dl
je 0x218d7
jmp 0x218e8
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6359
movq %rax, %rcx
movzbl (%rax), %eax
cmpl $0x79, %eax
je 0x218e2
cmpl $0x78, %eax
jne 0x218e8
xorl %eax, %eax
cmpb $0x0, 0x1(%rcx)
sete %al
testl %eax, %eax
je 0x218e8
cmpl $0x1, %eax
je 0x218f6
jmp 0x218f2
cmpb $0x0, 0x1(%rcx)
je 0x218f2
movq %rbx, %rdi
callq 0x64cd
jmp 0x21903
addq $0x8, %r14
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64e1
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_mt_add
int Pair_mt_add(lua_State *L) {

  // Expected: stack = [self, other]
  // other may be a Pair or a table of the form {x, y}.
  
  // Extract the pairs p, q from the stack.
  Pair *pair = (Pair *)luaL_checkudata(L, 1, Pair_metatable);
  lua_Number p[2] = {pair->x, pair->y};
  lua_Number q[2];
  for (int i = 0; i < 2; ++i) {
    lua_pushnumber(L, i + 1);
      // stack = [self, other, i + 1]
    lua_gettable(L, 2);
      // stack = [self, other, other[i + 1]]
    if (lua_type(L, -1) != LUA_TNUMBER) {
      return luaL_argerror(L, 2, "bad 2nd addend");
    }
    q[i] = lua_tonumber(L, -1);
    lua_pop(L, 1);
      // stack = [self, other]
  }
  lua_settop(L, 0);
    // stack = []

  // Set up a new table with the sum.
  push_new_pair(L, p[0] + q[0], p[1] + q[1]);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x761(%rip), %rdx       # 0x2208d
movl $0x1, %esi
callq 0x14e5d
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x1637(%rip), %xmm0     # 0x22f88
leaq -0x30(%rbp), %r12
movb $0x1, %r14b
leaq -0x48(%rbp), %r15
movq %rbx, %rdi
callq 0x64e1
movq %rbx, %rdi
movl $0x2, %esi
callq 0x682e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x608f
cmpl $0x3, %eax
jne 0x219f4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x628e
movsd %xmm0, (%r12)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %r15, %r12
movsd 0x2688(%rip), %xmm0     # 0x24038
testb $0x1, %r14b
movl $0x0, %r14d
jne 0x2195c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d4d
movsd -0x40(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
addsd -0x48(%rbp), %xmm1
movq %rbx, %rdi
callq 0x217cb
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33e1(%rip), %rdx      # 0x24ddc
movq %rbx, %rdi
movl $0x2, %esi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1497c
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_mt_mul
int Pair_mt_mul(lua_State *L) {

  // Expected: stack = [self, scalar]

  // Extract the needed values.
  Pair *pair = (Pair *)luaL_checkudata(L, 1, Pair_metatable);
  lua_Number scalar = luaL_checknumber(L, 2);

  // Set up the new resulting Pair instance.
  push_new_pair(L, pair->x * scalar, pair->y * scalar);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x668(%rip), %rdx       # 0x2208d
movl $0x1, %esi
callq 0x14e5d
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x150a0
movapd %xmm0, %xmm1
movsd (%r14), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x8(%r14), %xmm1
movq %rbx, %rdi
callq 0x217cb
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x615(%rip), %r15       # 0x2208d
movl $0x1, %esi
movq %r15, %rdx
callq 0x14e5d
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x14dea
xorl %esi, %esi
testq %rax, %rax
je 0x21ac0
movsd (%r14), %xmm0
ucomisd (%rax), %xmm0
jne 0x21ac0
jp 0x21ac0
movsd 0x8(%rax), %xmm0
cmpeqsd 0x8(%r14), %xmm0
movq %xmm0, %rsi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x6725
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0xc1f8(%rip), %rdi      # 0xf2a5
movl $0x34, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22d0
leaq 0xc214(%rip), %rsi      # 0xf2da
leaq 0xc21b(%rip), %rdx      # 0xf2e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
leaq 0xc21d(%rip), %rdi      # 0xf2fb
movl $0x23, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22d0
leaq 0xc228(%rip), %rdi      # 0xf31f
movl $0x20, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22d0
leaq 0xc230(%rip), %rdi      # 0xf340
movl $0x2b, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x22d0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc7a5(%rip), %rsi      # 0xf8d8
callq 0x21d0
testl %eax, %eax
je 0x318d
leaq 0xc83a(%rip), %rsi      # 0xf97d
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
je 0x3196
cmpb $0x4d, (%r14)
jne 0x319f
cmpb $0x45, 0x1(%r14)
jne 0x3163
cmpb $0x0, 0x2(%r14)
je 0x31bb
leaq 0xc202(%rip), %rsi      # 0xf36c
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
je 0x31b2
cmpb $0x44, 0x1(%r14)
jne 0x31c4
cmpb $0x0, 0x2(%r14)
jne 0x31c4
leaq 0x128e9(%rip), %rax     # 0x15a74
jmp 0x31c2
leaq 0x129e8(%rip), %rax     # 0x15b7c
jmp 0x31c2
leaq 0x1200b(%rip), %rax     # 0x151a8
jmp 0x31c2
leaq 0xc1c6(%rip), %rsi      # 0xf36c
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
jne 0x31c4
leaq 0x128c3(%rip), %rax     # 0x15a7c
jmp 0x31c2
leaq 0x128b6(%rip), %rax     # 0x15a78
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x128ec(%rip), %rax     # 0x15b6c
cmpl $0x0, (%rax)
je 0x32df
leaq 0x128ec(%rip), %rcx     # 0x15b78
cmpl $0x0, (%rcx)
movl $0x0, (%rax)
setne %al
leaq 0x143c1(%rip), %rcx     # 0x17660
movq (%rcx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x32cf
leaq 0x128b2(%rip), %rax     # 0x15b68
movl (%rax), %edx
leaq 0x128b1(%rip), %rax     # 0x15b70
movl (%rax), %ecx
leaq 0xc888(%rip), %rsi      # 0xfb50
xorl %eax, %eax
callq 0x21e0
leaq 0x1289a(%rip), %rcx     # 0x15b70
movl (%rcx), %eax
leal 0x1(%rax), %edx
movl %edx, (%rcx)
jmp 0x3323
leaq 0x12892(%rip), %rax     # 0x15b78
cmpl $0x0, (%rax)
setne %al
leaq 0x1436d(%rip), %rcx     # 0x17660
movq (%rcx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x331a
leaq 0x1285e(%rip), %rax     # 0x15b68
movl (%rax), %edx
leaq 0xc86c(%rip), %rsi      # 0xfb7f
xorl %eax, %eax
callq 0x21e0
leaq 0x12847(%rip), %rax     # 0x15b68
movl (%rax), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x336f
testl %eax, %eax
js 0x3360
movl %eax, %r15d
xorl %ebp, %ebp
callq 0x77bb
cmpl $0x1, %r15d
adcl $0x0, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x336f
movl %eax, %r15d
testl %eax, %eax
jns 0x3340
jmp 0x3362
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11acf(%rip), %r14     # 0x17648
movq (%r14), %rax
testl %esi, %esi
jle 0x5bce
leaq 0x11ad1(%rip), %r15     # 0x17658
movq 0x18(%rax), %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, (%r15)
je 0x5ba8
movq (%rcx), %rsi
callq 0xce10
movq (%r14), %rax
movq 0x18(%rax), %rcx
movq %rcx, (%r15)
jmp 0x5bc0
leaq 0x11aa1(%rip), %rsi     # 0x17650
movl (%rdx), %ecx
cmpl %ecx, (%rsi)
je 0x5bc3
movq %rdx, %rsi
callq 0xcf65
movq (%r14), %rax
movl 0x8(%rax), %ecx
addl %ebx, %ecx
leaq 0x11a84(%rip), %rdx     # 0x17650
movl %ecx, (%rdx)
addl 0x8(%rax), %ebx
movq 0x18(%rax), %rax
cmpl 0x14(%rax), %ebx
jbe 0x5bdd
movl %ebx, 0x14(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x4, %esi
callq 0x5b6b
leaq 0x119ea(%rip), %r12     # 0x17648
movq (%r12), %rax
movl 0x8(%rax), %esi
leaq 0xaec1(%rip), %r15      # 0x10b2d
movq %r14, %rdi
xorl %edx, %edx
movl $0x2, %ecx
movq %r15, %r8
callq 0x78b7
movq (%r12), %rax
movl 0x8(%rax), %esi
addl $0x2, %esi
movq %r14, %rdi
xorl %edx, %edx
movl $0x2, %ecx
movq %r15, %r8
callq 0x78b7
movq (%r12), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd032
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0xfe56(%rip), %r14      # 0x15b60
cmpl $0x0, (%r14)
sete %cl
leaq 0xf490(%rip), %r15      # 0x151a8
movl (%r15), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x5da5
movq %rdi, %rbx
xorl %ecx, %ecx
movl (%rbx), %edx
leal -0x8(%rdx), %esi
cmpl $0x6, %esi
jae 0x5d47
movq 0x18(%rbx), %rdi
callq 0x5cfe
movl (%r14), %ecx
movl (%r15), %eax
jmp 0x5d4f
leal -0x5(%rdx), %esi
cmpl $0x2, %esi
jae 0x5d62
movq 0x10(%rbx), %rbx
testl %ecx, %ecx
sete %dl
testb %dl, %dl
je 0x5da5
testl %eax, %eax
jne 0x5d2c
jmp 0x5da5
cmpl $0x7, %edx
jne 0x5d74
movq 0x10(%rbx), %rbx
movb $0x1, %dl
testq %rbx, %rbx
jne 0x5d58
jmp 0x5da5
cmpl $0x3, %edx
jne 0x5da5
movq 0x10(%rbx), %rax
testb $0x20, 0x10(%rax)
jne 0x5da5
movq (%rax), %rdi
leaq 0xf4a3(%rip), %rcx      # 0x15230
leaq 0x1991c(%rip), %r8      # 0x1f6b0
xorl %esi, %esi
movl $0x2, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x9f77
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x198f3(%rip), %rdi     # 0x1f6b0
leaq 0x8(%rsp), %rsi
callq 0x9ef7
testq %rax, %rax
je 0x5e31
movq %rax, %r12
leaq 0x118ba(%rip), %rbx     # 0x17690
leaq 0x198d3(%rip), %r14     # 0x1f6b0
leaq 0x8(%rsp), %r15
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x9e32
testq %rax, %rax
jne 0x5e1e
movl 0x10(%r12), %edx
orl $0x40, %edx
movl %edx, 0x10(%r12)
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq 0x18(%r12), %rcx
movq %rbx, %r8
callq 0x9f77
movl 0xc(%r12), %ecx
movl %ecx, 0xc(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9ea4
movq %rax, %r12
testq %rax, %rax
jne 0x5de2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5cfe
movl (%r15), %ecx
xorl %eax, %eax
addl $-0x2, %ecx
cmpl $0x7, %ecx
ja 0x5e7d
leaq 0xa368(%rip), %rdx      # 0x101cc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%r15), %rax
movq %rax, (%r14)
xorl %eax, %eax
movl %eax, (%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%r15), %rcx
movl (%rcx), %edx
andl $-0x2, %edx
cmpl $0x2, %edx
jne 0x5e7d
movq 0x18(%r15), %rdx
cmpl $0x1, (%rdx)
jne 0x5e7d
movq 0x10(%rcx), %rax
movq %rax, (%r14)
xorl %eax, %eax
subl 0x10(%rdx), %eax
jmp 0x5e76
movq 0x10(%r15), %rcx
movl (%rcx), %edx
andl $-0x2, %edx
cmpl $0x2, %edx
jne 0x5e7d
movq 0x18(%r15), %rdx
cmpl $0x1, (%rdx)
jne 0x5e7d
movq 0x10(%rcx), %rax
movq %rax, (%r14)
movl 0x10(%rdx), %eax
jmp 0x5e76
// File: /workspace/github_c_makefile_star2_O3/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 0x5b6b
movq %r12, %rdi
callq 0x5cfe
leaq 0xc(%rsp), %r13
movq %r13, %rdi
callq 0xd623
movq %r13, %rdi
movq %r12, %rsi
callq 0x5ecb
testl %eax, %eax
je 0x654c
leaq 0x11132(%rip), %r12     # 0x17648
movq (%r12), %rax
movl 0x8(%rax), %esi
leaq 0xa409(%rip), %r8       # 0x1092d
movq %r15, %rdi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x78b7
movq (%r12), %rsi
addq $0x8, %rsi
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %edx
xorl %r8d, %r8d
callq 0xd819
jmp 0x656c
leaq 0x9d7b(%rip), %rsi      # 0x102ce
movq %r15, %rdi
xorl %eax, %eax
callq 0x7a34
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x5be3
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movl (%rbx), %eax
cmpl $0xc, %eax
je 0x65a0
cmpl $0xd, %eax
jne 0x65b3
movq 0x10(%rbx), %rdi
callq 0x657d
testl %eax, %eax
je 0x65ad
jmp 0x65ba
movq 0x10(%rbx), %rdi
callq 0x657d
testl %eax, %eax
je 0x65bf
movq 0x18(%rbx), %rbx
jmp 0x6585
decl %eax
cmpl $0x2, %eax
jae 0x65bf
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movl (%rbx), %eax
cmpl $0xc, %eax
je 0x65eb
cmpl $0xd, %eax
jne 0x65fe
movq 0x10(%rbx), %rdi
callq 0x65c8
testl %eax, %eax
je 0x65f8
jmp 0x6603
movq 0x10(%rbx), %rdi
callq 0x65c8
testl %eax, %eax
je 0x6608
movq 0x18(%rbx), %rbx
jmp 0x65d0
cmpl $0x3, %eax
jne 0x6608
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10e93(%rip), %r14     # 0x174b0
movslq (%r14), %rcx
leaq 0x1(%rcx), %rax
movl %eax, (%r14)
cmpq $0xff, %rcx
jge 0x666d
movq %rsi, %rbx
leaq (%rax,%rax,2), %rax
leaq 0xf672(%rip), %r15      # 0x15cb0
movl %edi, (%r15,%rax,8)
movq 0x8(%rsi), %rdi
callq 0x22e0
movq %rax, %rdi
callq 0xe094
movslq (%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rax, 0x8(%r15,%rcx,8)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r15,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9bac(%rip), %rdi      # 0x10220
leaq 0x9bbb(%rip), %rsi      # 0x10236
leaq 0x9bc3(%rip), %rcx      # 0x10245
movl $0x233, %edx            # imm = 0x233
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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 0x5cfe
cmpl $0x1, (%r12)
jne 0x6730
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 0x5be3
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
callq 0x5e3d
testl %eax, %eax
je 0x6778
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
andl $0xa, %ecx
cmpl $0x2, %ecx
jne 0x6793
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 0x6397
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x64c6
movq 0x18(%rax), %rdx
leaq 0x10eaa(%rip), %rsi     # 0x17648
movl 0xc(%rsp), %ecx
addl 0x8(%rax), %ecx
movq (%rsi), %rax
movq (%r15), %rdi
cmpq 0x18(%rax), %rdx
je 0x67c9
movq (%rdx), %r8
movq %r14, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x645b
movq %r14, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6402
// File: /workspace/github_c_makefile_star2_O3/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 0x682c
leaq 0x10e48(%rip), %rax     # 0x17648
movq (%rax), %rax
testb $0x1, 0x8(%rax)
je 0x682c
movq (%r15), %rdi
leaq 0x9717(%rip), %rsi      # 0xff2a
xorl %eax, %eax
callq 0x7a34
movq (%r15), %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x5be3
movq %r12, %rdi
callq 0x8744
movq %rax, %rbp
movb (%rax), %al
leaq 0x4(%rsp), %r12
cmpb $0x2c, %al
jne 0x6853
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x5be3
jmp 0x689c
movq %rbp, %rdi
xorl %esi, %esi
callq 0x8fc7
movq %rax, %r13
cmpq %rbp, 0x8(%rax)
jbe 0x687c
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0x66ee
movq 0x8(%r13), %rbp
jmp 0x6894
movq (%r15), %rdi
leaq 0x99dd(%rip), %rsi      # 0x10263
xorl %eax, %eax
callq 0x7a34
leaq 0xa299(%rip), %rbp      # 0x10b2d
movq %r13, %rdi
callq 0x6d77
movq %rbp, %rdi
movq %r12, %rsi
callq 0x8785
movq %rax, %rbp
movzbl (%rax), %eax
cmpq $0x3b, %rax
ja 0x683e
movabsq $0x800000000000401, %rcx # imm = 0x800000000000401
btq %rax, %rcx
jae 0x683e
cmpl $0x0, 0x4(%rsp)
je 0x68dd
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x5be3
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %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
movl $0x1, %ebp
testb %dl, %cl
jne 0x694d
movslq %eax, %rdi
movq %rsp, %r14
movq %r14, %rsi
movl $0x8, %edx
callq 0xdf28
movq (%rbx), %rdi
leaq 0x993f(%rip), %rsi      # 0x10280
xorl %ebp, %ebp
movq %r14, %rdx
xorl %eax, %eax
callq 0x7a34
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6e2d
movq %rdi, %rbx
movl $0x28, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rax, %r14
movq (%rbx), %rdi
callq 0x22e0
movq %rax, %rdi
callq 0xe094
movq %rax, (%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x6e30
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6e9c
movq %rdi, %r14
movl $0x20, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
decl %eax
cmpl $0xc, %eax
ja 0x6ec7
leaq 0x94cd(%rip), %rcx      # 0x10344
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %rdi
callq 0x6e3b
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdi
callq 0x6e3b
movq %rax, 0x18(%rbx)
jmp 0x6ec7
xorl %ebx, %ebx
jmp 0x6ec7
movq 0x10(%r14), %rdi
callq 0x6e3b
jmp 0x6ec3
movq 0x10(%r14), %rdi
callq 0x6dd8
jmp 0x6ec3
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
jmp 0x6ec7
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x28, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rax, %r12
movq %r15, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0xe094
movq %rax, (%r12)
movl $0x0, 0x10(%r12)
leaq 0xe564(%rip), %rax      # 0x15b64
movl (%rax), %eax
movl %eax, 0xc(%r12)
movq $0x0, 0x20(%r12)
movq %r14, 0x18(%r12)
movl %ebx, 0x8(%r12)
movl $0x20, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
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_O3/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 %rbx
movl %edi, %ebx
movl $0x20, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movl $0x1, (%rax)
movl %ebx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x20, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movl %ebp, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x20, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rbx, 0x8(%rax)
movl $0x7, (%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0xff94(%rip)      # 0x17660
je 0x77ba
leaq 0xe487(%rip), %rax      # 0x15b60
cmpl $0x0, (%rax)
setle %al
cmpl $0x0, 0xff82(%rip)      # 0x17668
sete %cl
testb %cl, %al
jne 0x77ba
cmpl $0x0, 0xe388(%rip)      # 0x15a80
jle 0x77ba
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x9419(%rip), %rsi      # 0x10b2c
movq %r14, %rdi
callq 0x2180
movq %rax, %r15
movq 0xff4b(%rip), %rdi      # 0x17670
testq %rdi, %rdi
je 0x772f
callq 0x2050
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rax, %r12
movq %rax, 0xff23(%rip)      # 0x17670
movslq %r15d, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2220
movb $0x0, (%r12,%r15)
movq 0xff0e(%rip), %rdi      # 0x17678
testq %rdi, %rdi
jne 0x778b
movl $0x39, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rax, %rdi
movq %rax, 0xfeed(%rip)      # 0x17678
movl 0x10(%rbx), %r9d
leaq 0x8cb5(%rip), %rsi      # 0x1044b
leaq 0x9390(%rip), %rcx      # 0x10b2d
movl $0x2, %edx
movl $0x6, %r8d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0xfe9d(%rip)      # 0x17660
je 0x784e
leaq 0xe390(%rip), %rax      # 0x15b60
cmpl $0x0, (%rax)
setle %al
cmpl $0x0, 0xfe8b(%rip)      # 0x17668
sete %cl
testb %cl, %al
jne 0x784e
cmpl $0x0, 0xe295(%rip)      # 0x15a80
jle 0x784e
pushq %rax
movq 0xfe83(%rip), %rdi      # 0x17678
movl $0x28, %esi
callq 0xe10d
movq 0xfe72(%rip), %rdi      # 0x17678
movq 0xfe53(%rip), %rsi      # 0x17660
callq 0x2130
movq 0xfe57(%rip), %rdi      # 0x17670
movq 0xfe40(%rip), %rsi      # 0x17660
callq 0x2130
movq 0xfe34(%rip), %rsi      # 0x17660
movl $0xa, %edi
callq 0x2170
movq 0xfe33(%rip), %rax      # 0x17670
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0xfe30(%rip), %rax      # 0x17678
movb %cl, (%rax)
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0xfe09(%rip)      # 0x17660
je 0x78b6
leaq 0xe300(%rip), %rax      # 0x15b60
cmpl $0x0, (%rax)
setle %al
cmpl $0x0, 0xfdfb(%rip)      # 0x17668
sete %cl
testb %cl, %al
jne 0x78b6
cmpl $0x0, 0xe205(%rip)      # 0x15a80
jle 0x78b6
pushq %rax
movq 0xfdf3(%rip), %rax      # 0x17678
movb $0x0, (%rax)
movl 0x10(%rdi), %r9d
movzwl %si, %ecx
movl %ecx, (%rsp)
leaq 0x8bb9(%rip), %rsi      # 0x10452
leaq 0x928d(%rip), %rcx      # 0x10b2d
movq %rax, %rdi
movl $0x2, %edx
movl $0x6, %r8d
xorl %eax, %eax
callq 0x22b0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/crossassemblers/macro11/listing.c
// Function: list_word
static int dolist(
    void)
{
    int             ok = lstfile != NULL &&
                         (pass > 0 || list_pass_0) &&
                         list_level > 0;

    return ok;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0xfd9a(%rip)      # 0x17660
je 0x7947
movl %ecx, %r14d
leaq 0xe28e(%rip), %rax      # 0x15b60
cmpl $0x0, (%rax)
setle %al
cmpl $0x0, 0xfd89(%rip)      # 0x17668
sete %cl
testb %cl, %al
jne 0x7947
cmpl $0x0, 0xe193(%rip)      # 0x15a80
jle 0x7947
movq %r8, %rbx
movl %edx, %ebp
callq 0x7952
movq 0xfd78(%rip), %r15      # 0x17678
movq %r15, %rdi
callq 0x20e0
addq %rax, %r15
cmpl $0x1, %r14d
movl $0xff, %eax
movl $0xffff, %edx           # imm = 0xFFFF
cmovel %eax, %edx
leaq 0x8b43(%rip), %rax      # 0x10466
leaq 0x8b4b(%rip), %rsi      # 0x10475
cmoveq %rax, %rsi
andl %ebp, %edx
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfd11(%rip), %r14      # 0x17678
movq %r14, %rdi
callq 0x20e0
cmpq $0x28, %rax
jb 0x79ad
callq 0x77bb
movq 0xfcef(%rip), %rax      # 0x17670
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0xfcec(%rip), %rdi      # 0x17678
movb %cl, (%rdi)
leaq 0x8afd(%rip), %rsi      # 0x10492
leaq 0x9191(%rip), %rcx      # 0x10b2d
movl $0x8, %edx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x22b0
jmp 0x79dd
cmpq $0x8, %rax
ja 0x79f7
movl 0x10(%r15), %r9d
movl %ebx, (%rsp)
leaq 0x8adb(%rip), %rsi      # 0x1049c
leaq 0x9165(%rip), %rcx      # 0x10b2d
movq %r14, %rdi
movl $0x2, %edx
movl $0x6, %r8d
xorl %eax, %eax
callq 0x22b0
movq 0xfc94(%rip), %rdi      # 0x17678
movl $0x10, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe10d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a97
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 0xe0c2(%rip), %rax      # 0x15b60
cmpl $0x0, (%rax)
jne 0x7abe
cmpl $0x2, 0xfbbe(%rip)      # 0x17668
jge 0x7abe
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rdi, %rdi
jne 0x7ace
xorl %ebp, %ebp
leaq 0x9035(%rip), %r14      # 0x10b01
jmp 0x7ad5
movq 0x8(%rdi), %r14
movl 0x10(%rdi), %ebp
movq 0xd51c(%rip), %r15      # 0x14ff8
movq (%r15), %rdi
leaq 0x899b(%rip), %rsi      # 0x10481
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 0xfb37(%rip), %rdi      # 0x17660
testq %rdi, %rdi
je 0x7aac
leaq 0x8948(%rip), %rsi      # 0x10481
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 0xfafc(%rip), %rdi      # 0x17660
movq %rbx, %rsi
callq 0x2280
jmp 0x7aac
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rax, %r14
movq 0x8(%r13), %rdi
callq 0x20e0
leaq 0x20(%rax), %rdi
callq 0x2230
movq %rax, %rdi
callq 0xe094
movq %rax, %rbp
movq 0x8(%r13), %rdx
movl 0x10(%r13), %ecx
movq (%r12), %r8
leaq 0x88dc(%rip), %rsi      # 0x104c0
movq %rax, %rdi
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xdc63
movq %rbp, %rdi
callq 0x2050
leaq 0xde7d(%rip), %rax      # 0x15a88
movq %rax, (%r14)
movl %ebx, 0x30(%r14)
leaq 0xf897(%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