LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: PrintOC
void PrintOC(int v)
{

   if (!ListOn) return;
   // special format for 32 bit load

   if (oc == 0xcd) // LDQ immediate
   {
      fprintf(lf," cd %4.4x %4.4x",(v>>16)&0xffff,v&0xffff);
      return;
   }

   // opcode value is 16 or 8 bit

   if (oc > 255) fprintf(lf," %4.4x",oc);
   else          fprintf(lf,"   %2.2x",oc);

   // postbyte

   if (pb >= 0)  fprintf(lf," %2.2x",pb);
   else          fprintf(lf,"   ");

   // address or value 16 bit, 8 bit or none

        if (ql == 2) fprintf(lf," %4.4x",v&0xffff);
   else if (ql == 1) fprintf(lf,"   %2.2x",v&0xff);
   else              fprintf(lf,"     ");
}

// Assembly:
pushq %rbx
cmpl $0x0, 0xf14e(%rip)      # 0x121b8
je 0x309a
movl %edi, %ebx
movl 0x229a8(%rip), %edx     # 0x25a1c
cmpl $0xcd, %edx
jne 0x309c
movq 0x22985(%rip), %rdi     # 0x25a08
movl %ebx, %edx
shrl $0x10, %edx
movzwl %bx, %ecx
leaq 0x91dd(%rip), %rsi      # 0xc26f
xorl %eax, %eax
popq %rbx
jmp 0x2210
popq %rbx
retq
cmpl $0x100, %edx            # imm = 0x100
movq 0x2295f(%rip), %rdi     # 0x25a08
leaq 0xa514(%rip), %rax      # 0xd5c4
leaq 0x91e2(%rip), %rsi      # 0xc299
cmovgeq %rax, %rsi
xorl %eax, %eax
callq 0x2210
movl 0x22958(%rip), %edx     # 0x25a20
movq 0x22939(%rip), %rcx     # 0x25a08
testl %edx, %edx
js 0x30e6
leaq 0x91c1(%rip), %rsi      # 0xc29b
movq %rcx, %rdi
xorl %eax, %eax
callq 0x2210
jmp 0x30fc
leaq 0xa5c7(%rip), %rdi      # 0xd6b4
movl $0x3, %esi
movl $0x1, %edx
callq 0x2300
movl 0x22922(%rip), %eax     # 0x25a24
movq 0x228ff(%rip), %rcx     # 0x25a08
cmpl $0x1, %eax
je 0x311f
cmpl $0x2, %eax
jne 0x3134
movzwl %bx, %edx
leaq 0xa4a7(%rip), %rsi      # 0xd5c4
jmp 0x3129
movzbl %bl, %edx
leaq 0x9170(%rip), %rsi      # 0xc299
movq %rcx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x2210
leaq 0xa577(%rip), %rdi      # 0xd6b2
movl $0x5, %esi
movl $0x1, %edx
popq %rbx
jmp 0x2300
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: PrintByteLine
void PrintByteLine(int b)
{
   if (!ListOn || Pass) return;
   PrintLiNo();
   fprintf(lf,"       %2.2x",b);
   fprintf(lf,"         %s\n",Line);
}

// Assembly:
cmpl $0x0, 0xefd8(%rip)      # 0x121b8
je 0x3246
cmpl $0x0, 0x2282f(%rip)     # 0x25a18
jne 0x3246
pushq %rbx
movl %edi, %ebx
cmpl $0x0, 0x21b67(%rip)     # 0x24d5c
je 0x3212
movq 0x2280a(%rip), %rdi     # 0x25a08
movl 0x21b54(%rip), %edx     # 0x24d58
leaq 0x905f(%rip), %rsi      # 0xc26a
xorl %eax, %eax
callq 0x2210
movq 0x227ef(%rip), %rdi     # 0x25a08
leaq 0x9075(%rip), %rsi      # 0xc295
movl %ebx, %edx
xorl %eax, %eax
callq 0x2210
movq 0x227d8(%rip), %rdi     # 0x25a08
leaq 0x9051(%rip), %rsi      # 0xc288
leaq 0x21c62(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
popq %rbx
jmp 0x2210
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: PrintWordLine
void PrintWordLine(int w)
{
   if (!ListOn || Pass) return;
   PrintLiNo();
   fprintf(lf,"%4.4x",w);
   fprintf(lf,"              %s\n",Line);
}

// Assembly:
cmpl $0x0, 0xef6a(%rip)      # 0x121b8
je 0x32b4
cmpl $0x0, 0x227c1(%rip)     # 0x25a18
jne 0x32b4
pushq %rbx
movl %edi, %ebx
cmpl $0x0, 0x21af9(%rip)     # 0x24d5c
je 0x3280
movq 0x2279c(%rip), %rdi     # 0x25a08
movl 0x21ae6(%rip), %edx     # 0x24d58
leaq 0x8ff1(%rip), %rsi      # 0xc26a
xorl %eax, %eax
callq 0x2210
movq 0x22781(%rip), %rdi     # 0x25a08
leaq 0xa337(%rip), %rsi      # 0xd5c5
movl %ebx, %edx
xorl %eax, %eax
callq 0x2210
movq 0x2276a(%rip), %rdi     # 0x25a08
leaq 0x8fde(%rip), %rsi      # 0xc283
leaq 0x21bf4(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
popq %rbx
jmp 0x2210
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: IsInstruction
int IsInstruction(char *p)
{
   int i,l;

   for (i = 0 ; i < DimOp ; ++i)
   {
      l = strlen(Mat[i].Mne);
      if (!StrNCaseCmp(p,Mat[i].Mne,l) && !isym(p[l]))
      {
         return i;
      }
   }
   return -1; // No mnemonic
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x112e9(%rip), %r13     # 0x145b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r13, %r13
jle 0x333e
movq %rdi, %r14
leaq 0xeee5(%rip), %r15      # 0x121c0
xorl %ebp, %ebp
movabsq $0x800000000000401, %rbx # imm = 0x800000000000401
movq %r15, %rdi
callq 0x2110
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x2c53
testl %eax, %eax
jne 0x332d
movslq %r12d, %rax
movzbl (%r14,%rax), %eax
leal -0x24(%rax), %ecx
cmpl $0x3b, %ecx
ja 0x331a
btq %rcx, %rbx
jb 0x332d
movsbq %al, %r12
callq 0x2320
movq (%rax), %rax
testb $0x8, (%rax,%r12,2)
je 0x334d
incq %rbp
addq $0x28, %r15
cmpq %rbp, %r13
jne 0x32e7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %eax
jmp 0x333e
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseCaseData
char *ParseCaseData(char *p)
{
   p = SkipSpace(p);
        if (*p == '+') IgnoreCase = 0;
   else if (*p == '-') IgnoreCase = 1;
   else
   {
      ++ErrNum;
      ErrorMsg("Missing '+' or '-' after CASE\n");
      exit(1);
   }
   PrintLine();
   return p+1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsbq (%rdi), %r14
testq %r14, %r14
je 0x33e1
movq %rdi, %rbx
callq 0x2320
movq (%rax), %rax
incq %rbx
testb $0x20, 0x1(%rax,%r14,2)
je 0x33b5
movsbq (%rbx), %r14
jmp 0x33a4
xorl %eax, %eax
cmpb $0x2b, %r14b
je 0x33cb
movzbl %r14b, %eax
cmpl $0x2d, %eax
jne 0x33e1
movl $0x1, %eax
movl %eax, 0x22657(%rip)     # 0x25a28
callq 0x314b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incl 0x22645(%rip)           # 0x25a2c
leaq 0x8eb4(%rip), %rdi      # 0xc2a2
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseListOption
char *ParseListOption(char *p)
{
   p = SkipSpace(p);
        if (*p == '+') ListGlobal = 1;
   else if (*p == '-') ListGlobal = 0;
   else
   {
      ++ErrNum;
      ErrorMsg("Missing '+' or '-' after LIST\n");
      exit(1);
   }
   ListOn = ListGlobal;
   PrintLine();
   return p+1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsbq (%rdi), %r14
testq %r14, %r14
je 0x345a
movq %rdi, %rbx
callq 0x2320
movq (%rax), %rax
incq %rbx
testb $0x20, 0x1(%rax,%r14,2)
je 0x3428
movsbq (%rbx), %r14
jmp 0x3417
movl $0x1, %eax
cmpb $0x2b, %r14b
je 0x343e
movzbl %r14b, %eax
cmpl $0x2d, %eax
jne 0x345a
xorl %eax, %eax
movl %eax, 0xed70(%rip)      # 0x121b4
movl %eax, 0xed6e(%rip)      # 0x121b8
callq 0x314b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incl 0x225cc(%rip)           # 0x25a2c
leaq 0x8e5a(%rip), %rdi      # 0xc2c1
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: SetBSS
char *SetBSS(char *p)
{
   p = NeedChar(p,'=');
   if (!p)
   {
      ++ErrNum;
      ErrorMsg("Missing '=' in set BSS & instruction\n");
      exit(1);
   }
   p = ExtractValue(p+1,&bss);
   if (ListOn && !Pass)
   {
      PrintLiNo();
      fprintf(lf,"%4.4x              %s\n",bss,Line);
   }
   return p;
}

// Assembly:
pushq %rbx
cmpb $0x0, (%rdi)
je 0x3511
movq %rdi, %rbx
callq 0x2320
movq (%rax), %rax
movb (%rbx), %cl
movsbq %cl, %rdx
incq %rbx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x348d
cmpb $0x3d, %cl
jne 0x3511
leaq 0x22587(%rip), %rsi     # 0x25a30
movq %rbx, %rdi
callq 0x352f
movq %rax, %rbx
cmpl $0x0, 0xecfd(%rip)      # 0x121b8
je 0x350c
cmpl $0x0, 0x22554(%rip)     # 0x25a18
jne 0x350c
cmpl $0x0, 0x2188f(%rip)     # 0x24d5c
je 0x34ea
movq 0x22532(%rip), %rdi     # 0x25a08
movl 0x2187c(%rip), %edx     # 0x24d58
leaq 0x8d87(%rip), %rsi      # 0xc26a
xorl %eax, %eax
callq 0x2210
movq 0x22517(%rip), %rdi     # 0x25a08
movl 0x22539(%rip), %edx     # 0x25a30
leaq 0x8e08(%rip), %rsi      # 0xc306
leaq 0x2199b(%rip), %rcx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
incl 0x22515(%rip)           # 0x25a2c
leaq 0x8dc2(%rip), %rdi      # 0xc2e0
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ExtractValue
char *ExtractValue(char *p, int *v)
{
   char *r; // pointer to trailing text after value (should be none)

   p = ExtractOpText(p);        // separate value string from comment
   if (OpText[0] == 0)
   {
      ErrorLine(p);
      ErrorMsg("Empty operand\n");
      exit(1);
   }
   r = EvalOperand(OpText,v,0); // evaluate integer value
   if (*r)                      // check for trailing text
   {
      ErrorLine(r);
      ErrorMsg("Extra text after operand\n");
      exit(1);
   }
   return p;                    // points to comment or EOL
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x36db
movq %rax, %rbx
cmpb $0x0, 0x21a5b(%rip)     # 0x24fa0
je 0x3568
leaq 0x21a52(%rip), %rdi     # 0x24fa0
movq %r14, %rsi
xorl %edx, %edx
callq 0x3e17
cmpb $0x0, (%rax)
jne 0x3579
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2dde
leaq 0x9095(%rip), %rdi      # 0xc60c
jmp 0x3588
movq %rax, %rdi
callq 0x2dde
leaq 0x9093(%rip), %rdi      # 0xc61b
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: MacroIndex
int MacroIndex(char *p)
{
   int i,l;

   for (i = 0 ; i < Macros ; ++i)
   {
      l = strlen(Mac[i].Name);
      if (!StrnCmp(p,Mac[i].Name,l) && !isym(p[l])) return i;
   }
   return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x7ffef(%rip), %r13     # 0x83640
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r13, %r13
jle 0x36c8
movq %rdi, %r14
leaq 0x7ffeb(%rip), %rbx     # 0x83650
xorl %ebp, %ebp
movq (%rbx), %r12
movq %r12, %rdi
callq 0x2110
movslq %eax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x35ab
testl %eax, %eax
jne 0x36b7
movzbl (%r14,%r15), %eax
leal -0x24(%rax), %ecx
cmpl $0x3b, %ecx
ja 0x36a4
movabsq $0x800000000000401, %rdx # imm = 0x800000000000401
btq %rcx, %rdx
jb 0x36b7
movsbq %al, %r15
callq 0x2320
movq (%rax), %rax
testb $0x8, (%rax,%r15,2)
je 0x36d7
incq %rbp
addq $0x20, %rbx
cmpq %rbp, %r13
jne 0x3667
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %eax
jmp 0x36c8
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ExtractOpText
char *ExtractOpText(char *p)
{
   int l,inquo,inapo;

   l          = 0; // length of trimmed operand
   inquo      = 0; // inside quotes
   inapo      = 0; // inside apostrophes
   ForcedMode = 0; // forced direct page (-1) or extended (+1)
   OpText[0]  = 0; // empty operand text

   p = SkipSpace(p);  // text after mnemonic or pseudo op
   if (!*p) return p; // end of line

   if (*p == '<' || *p == '>')
   {
      ForcedMode = *p - 0x3d; // -1 for '<', +1 for '>'
      ++p;
   }

   // Extract operand

   if (CodeStyle == 1) // Thomson style
   {
      while (*p && *p != ' ' && l < ML) OpText[l++] = *p++;
   }
   else
   {
      while (*p && l < ML)
      {
         if (*p == '"'  && inapo == 0) inquo = !inquo;
         if (*p == '\'' && inquo == 0) inapo = !inapo;
         if (*p == ';'  && inquo == 0 && inapo == 0) break;
         OpText[l++] = *p++;
      }
      while (l && isspace(OpText[l-1])) OpText[--l] = 0;
   }
   OpText[l] = 0; // end marker
   // if (df) fprintf(df,"OpText = [%s]\n",OpText);
   return p;      // points to comment start or EOL
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x81864(%rip)     # 0x84f50
movb $0x0, 0x218ad(%rip)     # 0x24fa0
movsbq (%rdi), %r14
testq %r14, %r14
je 0x3847
callq 0x2320
movq (%rax), %rdx
leaq 0x1(%rbx), %rcx
testb $0x20, 0x1(%rdx,%r14,2)
je 0x3727
movsbq (%rcx), %r14
incq %rcx
testb $0x20, 0x1(%rdx,%r14,2)
jne 0x3714
leaq -0x1(%rcx), %rbx
testb %r14b, %r14b
je 0x3847
movzbl %r14b, %edx
cmpl $0x3e, %edx
je 0x373e
cmpl $0x3c, %edx
jne 0x374a
addl $-0x3d, %edx
movl %edx, 0x81809(%rip)     # 0x84f50
movq %rcx, %rbx
cmpl $0x1, 0x81803(%rip)     # 0x84f54
movb (%rbx), %cl
jne 0x3798
testb %cl, %cl
je 0x3837
xorl %esi, %esi
leaq 0x2183a(%rip), %rax     # 0x24fa0
cmpb $0x20, %cl
je 0x380a
cmpq $0xff, %rsi
ja 0x380a
leaq 0x1(%rsi), %rdx
movb %cl, (%rsi,%rax)
movb 0x1(%rbx,%rsi), %cl
movq %rdx, %rsi
testb %cl, %cl
jne 0x3766
addq %rdx, %rbx
movl %edx, %esi
jmp 0x3839
testb %cl, %cl
je 0x3837
xorl %esi, %esi
leaq 0x217f7(%rip), %rdx     # 0x24fa0
xorl %r8d, %r8d
xorl %edi, %edi
movl %r8d, %r9d
xorl %r10d, %r10d
testl %edi, %edi
sete %r10b
xorl %r8d, %r8d
testl %r9d, %r9d
cmovnel %edi, %r10d
sete %r8b
cmpb $0x22, %cl
cmovel %r10d, %edi
testl %edi, %edi
cmovnel %r9d, %r8d
cmpb $0x27, %cl
cmovnel %r9d, %r8d
cmpb $0x3b, %cl
jne 0x37ea
testl %edi, %edi
jne 0x37ea
testl %r8d, %r8d
je 0x380f
leaq 0x1(%rsi), %r9
movb %cl, (%rsi,%rdx)
movb 0x1(%rbx,%rsi), %cl
testb %cl, %cl
je 0x3805
cmpq $0xff, %rsi
movq %r9, %rsi
jb 0x37ae
addq %r9, %rbx
jmp 0x381a
addq %rsi, %rbx
jmp 0x3839
addq %rsi, %rbx
testq %rsi, %rsi
je 0x3837
movl %esi, %r9d
movl %r9d, %esi
movq (%rax), %rcx
movsbq -0x1(%rsi,%rdx), %rdi
testb $0x20, 0x1(%rcx,%rdi,2)
je 0x3839
movb $0x0, -0x1(%rsi,%rdx)
decq %rsi
jne 0x381d
xorl %esi, %esi
movslq %esi, %rax
leaq 0x2175d(%rip), %rcx     # 0x24fa0
movb $0x0, (%rax,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: SymRefs
void SymRefs(int i)
{
   int n;

   if (Pass) return;
   n = ++lab[i].NumRef;
   lab[i].Ref = (int *)ReallocOrDie(lab[i].Ref,(n+1)*sizeof(int));
   lab[i].Ref[n] = LiNo;
   lab[i].Att = (int *)ReallocOrDie(lab[i].Att,(n+1)*sizeof(int));
   lab[i].Att[n] = am;
}

// Assembly:
cmpl $0x0, 0x218cc(%rip)     # 0x25a18
je 0x414f
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %edi, %rax
leaq (%rax,%rax,2), %r15
shlq $0x4, %r15
leaq 0x218d6(%rip), %r13     # 0x25a40
movslq 0x18(%r15,%r13), %r12
leaq 0x1(%r12), %rax
movl %eax, 0x18(%r15,%r13)
movq 0x20(%r15,%r13), %rdi
leaq 0x8(,%r12,4), %rbx
movq %rbx, %rsi
callq 0x2280
movq %rax, %r14
movq %rax, %rdi
callq 0x2834
movq %r14, 0x20(%r15,%r13)
movl 0x20bb4(%rip), %eax     # 0x24d58
movl %eax, 0x4(%r14,%r12,4)
movq 0x28(%r15,%r13), %rdi
movq %rbx, %rsi
callq 0x2280
movq %rax, %rbx
movq %rax, %rdi
callq 0x2834
movq %rbx, 0x28(%r15,%r13)
movl 0x80e98(%rip), %eax     # 0x85064
movl %eax, 0x4(%rbx,%r12,4)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: EvalSymValue
char *EvalSymValue(char *p, int *v)
{
   int i;
   char Sym[ML];

   p = GetSymbol(p,Sym);
   for (i=0 ; i < Labels ; ++i)
   {
      if (!StrCmp(Sym,lab[i].Name))
      {
         *v = lab[i].Address;
         SymRefs(i);
         return p;
      }
   }
   AddLabel(Sym);
   *v = UNDEF;
   return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rsp, %rsi
callq 0x2a9c
movq %rax, %rbx
movslq 0x21833(%rip), %r13     # 0x25a34
testq %r13, %r13
jle 0x422f
leaq 0x21833(%rip), %rbp     # 0x25a40
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x3599
testl %eax, %eax
je 0x4240
incq %r15
addq $0x30, %rbp
cmpq %r15, %r13
jne 0x4213
movq %rsp, %rdi
callq 0x4263
movl $0xff0000, (%r14)       # imm = 0xFF0000
jmp 0x424e
movl 0xc(%rbp), %eax
movl %eax, (%r14)
movl %r15d, %edi
callq 0x4145
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: AddLabel
void AddLabel(char *p)
{
   int i,l;

   if (Labels > MAXLAB -2)
   {
      ++ErrNum;
      ErrorMsg("Too many labels (> %d)\n",MAXLAB);
      exit(1);
   }
   l = strlen(p);

   // test for mnemonic

   for (i=0 ; i < DimOp ; ++i)
   {
      if (!StrCaseCmp(p,Mat[i].Mne))
      {
         ErrorMsg("Use of reserved mnemonic <%s> as label or operand\n",p);
         exit(1);
      }
   }

   // test for pseudos

   for (i=0 ; i < PSEUDOS ; ++i)
   {
      if (!StrCaseCmp(p,PseudoTab[i].keyword))
      {
         ErrorMsg("Use of reserved keyword <%s> as label or operand\n",p);
         exit(1);
      }
   }

   lab[Labels].Address = UNDEF;
   lab[Labels].Name = (char *)StrNDup(p,l);
   lab[Labels].Ref = (int *)MallocOrDie(sizeof(int));
   lab[Labels].Att = (int *)MallocOrDie(sizeof(int));
   lab[Labels].Ref[0] = LiNo;
   lab[Labels].Att[0] = 0;
   Labels++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x217c1(%rip), %r12     # 0x25a34
cmpq $0x1f3f, %r12           # imm = 0x1F3F
jge 0x43d2
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
movslq 0x1031e(%rip), %r13     # 0x145b0
testq %r13, %r13
jle 0x42ba
leaq 0xdf22(%rip), %r15      # 0x121c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2be8
testl %eax, %eax
je 0x43b7
addq $0x28, %r15
decq %r13
jne 0x429e
xorl %r15d, %r15d
leaq 0x1074c(%rip), %r13     # 0x14a10
movq (%r15,%r13), %rsi
movq %rbx, %rdi
callq 0x2be8
testl %eax, %eax
je 0x43ae
addq $0x10, %r15
cmpq $0x220, %r15            # imm = 0x220
jne 0x42c4
leaq (%r12,%r12,2), %rax
shlq $0x4, %rax
leaq 0x2174c(%rip), %r15     # 0x25a40
movl $0xff0000, 0xc(%rax,%r15) # imm = 0xFF0000
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2878
movslq 0x21725(%rip), %rcx     # 0x25a34
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq %rax, (%rcx,%r15)
movl $0x4, %edi
movl $0x1, %esi
callq 0x21e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x2834
movslq 0x216f8(%rip), %rax     # 0x25a34
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq %rbx, 0x20(%rax,%r15)
movl $0x4, %edi
movl $0x1, %esi
callq 0x21e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x2834
movslq 0x216ca(%rip), %rax     # 0x25a34
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq %rbx, 0x28(%rax,%r15)
movl 0x209db(%rip), %ecx     # 0x24d58
movq 0x20(%rax,%r15), %rax
movl %ecx, (%rax)
movslq 0x216a9(%rip), %rax     # 0x25a34
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x28(%rax,%r15), %rax
movl $0x0, (%rax)
incl 0x21690(%rip)           # 0x25a34
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x894f(%rip), %rdi      # 0xcd04
jmp 0x43be
leaq 0x8913(%rip), %rdi      # 0xccd1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
incl 0x21654(%rip)           # 0x25a2c
leaq 0x7f3e(%rip), %rdi      # 0xc31d
movl $0x1f40, %esi           # imm = 0x1F40
xorl %eax, %eax
callq 0x2e72
jmp 0x43c8
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: EvalSymBytes
char *EvalSymBytes(char *p, int *v)
{
   int i;
   char Sym[ML];

   p = GetSymbol(p,Sym);
   for (i=0 ; i < Labels ; ++i)
   {
      if (!StrCmp(Sym,lab[i].Name))
      {
         *v = lab[i].Bytes;
         SymRefs(i);
         return p;
      }
   }
   AddLabel(Sym);
   *v = UNDEF;
   return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rsp, %rsi
callq 0x2a9c
movq %rax, %rbx
movslq 0x21621(%rip), %r13     # 0x25a34
testq %r13, %r13
jle 0x4441
leaq 0x21631(%rip), %rbp     # 0x25a50
xorl %r15d, %r15d
movq %rsp, %r12
movq -0x10(%rbp), %rsi
movq %r12, %rdi
callq 0x3599
testl %eax, %eax
je 0x4452
incq %r15
addq $0x30, %rbp
cmpq %r15, %r13
jne 0x4425
movq %rsp, %rdi
callq 0x4263
movl $0xff0000, (%r14)       # imm = 0xFF0000
jmp 0x4460
movl (%rbp), %eax
movl %eax, (%r14)
movl %r15d, %edi
callq 0x4145
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: Hex2Byte
int Hex2Byte(char hex[])
{
   int h,l;
   h = Nib2Byte(hex[0]);
   l = Nib2Byte(hex[1]);
   if (h >= 0 && l >= 0) return (h << 4) | l;
   return -1;
}

// Assembly:
movsbl (%rdi), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x44b3
addl $-0x30, %eax
jmp 0x44d3
leal -0x41(%rax), %ecx
cmpb $0x5, %cl
ja 0x44c0
addl $-0x37, %eax
jmp 0x44d3
leal -0x61(%rax), %ecx
addl $-0x57, %eax
cmpb $0x6, %cl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovbl %eax, %ecx
movl %ecx, %eax
movsbl 0x1(%rdi), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x44e4
addl $-0x30, %ecx
jmp 0x4504
leal -0x41(%rcx), %edx
cmpb $0x5, %dl
ja 0x44f1
addl $-0x37, %ecx
jmp 0x4504
leal -0x61(%rcx), %edx
addl $-0x57, %ecx
cmpb $0x6, %dl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovbl %ecx, %edx
movl %edx, %ecx
movl %eax, %edx
shll $0x4, %edx
orl %ecx, %edx
orl %ecx, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: EvalDecValue
char *EvalDecValue(char *p, int *v)
{
   int i;

   // check for xxxxH or xxxxh hex syntax;

   for (i=0 ; i < 5 ; ++i) // allow max. 5 hex digits
      if (!isxdigit(p[i])) break;
   if (p[i] == 'H' || p[i] == 'h')
   {
      p = EvalHexValue(p,v);
      return p+1;
   }

   // check for decimal value

   *v = atoi(p);
   while (isdigit(*p)) ++p;
   if (!isalpha(*p)) return p;
   if ((*p >= 'A' && *p <= 'F') || (*p >= 'a' && *p <= 'f'))
      ErrorMsg("Wrong decimal constant or leading $ for hex missing\n");
   else
      ErrorMsg("Illegal character in decimal constant\n");
   ++ErrNum;
   ErrorLine(p);
   exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2320
movq (%rax), %r15
xorl %eax, %eax
movsbq (%rbx,%rax), %rcx
testb $0x10, 0x1(%r15,%rcx,2)
je 0x47e8
incq %rax
cmpq $0x5, %rax
jne 0x47cd
movl $0x5, %eax
movl %eax, %eax
movzbl (%rbx,%rax), %eax
orl $0x20, %eax
cmpl $0x68, %eax
jne 0x4816
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x10, %edx
callq 0x2200
movl %eax, (%r14)
movq (%r15), %rbx
incq %rbx
jmp 0x483d
movq %rbx, %rdi
callq 0x22d0
movl %eax, (%r14)
decq %rbx
movsbq 0x1(%rbx), %rax
incq %rbx
movzwl (%r15,%rax,2), %ecx
btl $0xb, %ecx
jb 0x4824
btl $0xa, %ecx
jb 0x484a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movzbl %al, %eax
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0x488b
movabsq $0x3f0000003f, %rcx     # imm = 0x3F0000003F
btq %rax, %rcx
jae 0x488b
leaq 0x7c38(%rip), %rdi      # 0xc4a4
xorl %eax, %eax
callq 0x2e72
incl 0x211b3(%rip)           # 0x25a2c
movq %rbx, %rdi
callq 0x2dde
movl $0x1, %edi
callq 0x22f0
leaq 0x7c47(%rip), %rdi      # 0xc4d9
jmp 0x486c
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: EvalCharValue
char *EvalCharValue(char *p, int *v)
{
   // a common error is to code '\' instead of '\\' for backslash.
   // we fix it here quietly by assuming that '\\' was intended
   // apostrophe would be coded as '\''

   // printf("%s %d %c\n",p,strncmp(p,"'\\'",3),p[3]);
   if (p[0]=='\\' && p[1]=='\'' && p[3]!='\'')
   {
      *v = '\\';
      p+=2;
   }

   else if (*p == '\\')
   {
      ++p;
           if (*p == 'r') *v = 13;
      else if (*p == 'n') *v = 10;
      else if (*p == 'a') *v =  7;
      else if (*p == 'e') *v = 27;
      else if (*p == '0') *v =  0;
      else                *v = *p;
      if (*p) ++p;
   }
   else *v = *p++;

   if (*p != '\'' && *p != 0)
   {
      ++ErrNum;
      ErrorMsg("Missing ' delimiter after character operand\n");
      exit(1);
   }
   if (*p) ++p;
   return p;
}

// Assembly:
movsbl (%rdi), %eax
cmpl $0x5c, %eax
jne 0x48bb
movzbl 0x1(%rdi), %eax
cmpl $0x64, %eax
jg 0x48c5
cmpl $0x27, %eax
je 0x48db
cmpl $0x30, %eax
je 0x48ed
cmpl $0x61, %eax
jne 0x48e1
movl $0x7, %ecx
jmp 0x48f6
incq %rdi
movl %eax, (%rsi)
movq %rdi, %rax
jmp 0x4908
cmpl $0x65, %eax
je 0x48e6
cmpl $0x6e, %eax
je 0x48f1
movl $0xd, %ecx
cmpl $0x72, %eax
je 0x48f6
jmp 0x48e1
cmpb $0x27, 0x3(%rdi)
jne 0x491c
movsbl %al, %ecx
jmp 0x48f6
movl $0x1b, %ecx
jmp 0x48f6
xorl %ecx, %ecx
jmp 0x48f6
movl $0xa, %ecx
leaq 0x1(%rdi), %rdx
movl %ecx, (%rsi)
leaq 0x2(%rdi), %rax
cmpb $0x0, 0x1(%rdi)
cmoveq %rdx, %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x4914
cmpl $0x27, %ecx
jne 0x4928
cmpb $0x1, %cl
sbbq $-0x1, %rax
retq
movl $0x5c, (%rsi)
addq $0x2, %rdi
jmp 0x48c0
pushq %rax
incl 0x210fd(%rip)           # 0x25a2c
leaq 0x7bca(%rip), %rdi      # 0xc500
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: EvalMultiCharValue
char *EvalMultiCharValue(char *p, int *v)
{
   int i;

   *v = 0;                     // preset with zero
   for (i=0 ; i < 4 ; ++i)
   {
      if (*p == '\"') break;   // end quote
      *v = (*v << 8) | *p++;
   }
   if (*p == '\"') ++p;        // end quote
   else ErrorMsg("Multi character operand too long ( > 4 )\n");
   return p;
}

// Assembly:
pushq %rbx
movl $0x0, (%rsi)
xorl %eax, %eax
xorl %ecx, %ecx
movsbl (%rdi,%rax), %edx
cmpl $0x22, %edx
je 0x4984
shll $0x8, %ecx
orl %edx, %ecx
movl %ecx, (%rsi)
incq %rax
cmpl $0x4, %eax
jne 0x4952
leaq (%rdi,%rax), %rbx
cmpb $0x22, (%rdi,%rax)
je 0x498a
leaq 0x7bb2(%rip), %rdi      # 0xc52d
xorl %eax, %eax
callq 0x2e72
jmp 0x498d
addq %rax, %rdi
movq %rdi, %rbx
incq %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: EvalBinValue
char *EvalBinValue(char *p, int *v)
{
   int r;
   r = 0;
   while(*p == ' ' || *p == '1' || *p == '0' || *p == '*' || *p == '.')
   {
      if (*p == '1' || *p == '*') r = (r << 1) + 1;
      if (*p == '0' || *p == '.') r <<= 1;
      ++p;
   }
   *v = r;
   return p;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
leaq 0x76e2(%rip), %rdx      # 0xc080
movzbl (%rax), %edi
leal -0x2a(%rdi), %r8d
cmpl $0x7, %r8d
ja 0x49be
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
leal 0x1(,%rcx,2), %ecx
jmp 0x49c3
cmpl $0x20, %edi
jne 0x49d4
cmpl $0x30, %edi
je 0x49cd
cmpl $0x2e, %edi
jne 0x49cf
addl %ecx, %ecx
incq %rax
jmp 0x499e
movl %ecx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: op_par
char *op_par(char *p, int *v)
{
   char c = (*p == '[') ? ']' : ')'; // closing char
   p = EvalOperand(p+1,v,0);
   p = NeedChar(p,c);
   if (!p)
   {
      ErrorLine(p);
      ErrorMsg("Missing closing %c\n",c);
      exit(1);
   }
   return p+1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpb $0x5b, (%rdi)
movl $0x5d, %eax
movl $0x29, %ebp
cmovel %eax, %ebp
incq %rdi
xorl %edx, %edx
callq 0x3e17
cmpb $0x0, (%rax)
je 0x4a43
movq %rax, %rbx
callq 0x2320
movq (%rax), %rax
movsbq (%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x4a26
cmpb %bpl, %cl
jne 0x4a43
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %edi, %edi
callq 0x2dde
movzbl %bpl, %esi
leaq 0x7b02(%rip), %rdi      # 0xc557
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: AlignFill
char *AlignFill(char *p, int *v, int *f)
{
   char *r; // pointer to text after value

   p = ExtractOpText(p);        // separate value string from comment
   if (OpText[0] == 0)
   {
      ErrorLine(p);
      ErrorMsg("Empty operand\n");
      exit(1);
   }
   r = EvalOperand(OpText,v,0); // evaluate integer value
   if (*r == 0) return p;       // no fill value specified
   if (*r != '(')               // check for fill value
   {
      ErrorLine(r);
      ErrorMsg("Illegal syntax for fill value\n");
      exit(1);
   }
   r = EvalOperand(r+1,f,0);    // evaluate fill value
   return p;                    // points to comment or EOL
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x36db
movq %rax, %rbx
cmpb $0x0, 0x20373(%rip)     # 0x24fa0
je 0x4c65
leaq 0x2036a(%rip), %rdi     # 0x24fa0
movq %r15, %rsi
xorl %edx, %edx
callq 0x3e17
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x4c5c
cmpl $0x28, %ecx
jne 0x4c76
incq %rax
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3e17
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2dde
leaq 0x7998(%rip), %rdi      # 0xc60c
jmp 0x4c85
movq %rax, %rdi
callq 0x2dde
leaq 0x79b0(%rip), %rdi      # 0xc635
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseFillData
char *ParseFillData(char *p)
{
   int i,m,v;

   p = EvalOperand(p,&m,0);
   if (m < 0 || m > 0xffff)
   {
      ErrorMsg("Illegal FILL multiplier %d\n",m);
      exit(1);
   }
   p = NeedChar(p,'(');
   if (!p)
   {
      ErrorMsg("Missing '(' before FILL value\n");
      exit(1);
   }
   p = EvalOperand(p+1,&v,0);
   v &= 0xff;
   if (!Pass)
   {
      for (i=0 ; i < m ; ++i) PutByte(pc+i,v);
      if (ListOn)
      {
         PrintPC();
         if (m > 0) fprintf(lf," %2.2x",v);
         else       fprintf(lf,"   ");
         if (m > 1) fprintf(lf," %2.2x",v);
         else       fprintf(lf,"   ");
         if (m > 2) fprintf(lf," %2.2x",v);
         else       fprintf(lf,"   ");
         fprintf(lf," %s ; %d bytes\n",Line,m);
      }
   }
   pc += m;
   p += strlen(p);
   return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x3e17
movl (%r14), %esi
cmpl $0x10000, %esi          # imm = 0x10000
jae 0x52b6
movq %rax, %rbx
cmpb $0x0, (%rax)
je 0x52a6
callq 0x2320
movq (%rax), %rax
movb (%rbx), %cl
movsbq %cl, %rdx
incq %rbx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x513c
cmpb $0x28, %cl
jne 0x52a6
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3e17
movq %rax, %rbx
cmpl $0x0, 0x208aa(%rip)     # 0x25a18
movl 0xc(%rsp), %r14d
jne 0x528b
testl %r14d, %r14d
jle 0x5207
movzbl 0x8(%rsp), %ebp
movslq 0xf5a6(%rip), %rax      # 0x14734
leaq 0xfabb(%rip), %rdi      # 0x14c50
addq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2180
cmpl $0x0, 0xd00f(%rip)      # 0x121b8
je 0x528b
callq 0x3014
movq 0x2084d(%rip), %rdi     # 0x25a08
leaq 0x70d9(%rip), %rsi      # 0xc29b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
cmpl $0x1, %r14d
je 0x5232
movq 0x20830(%rip), %rdi     # 0x25a08
leaq 0x70bc(%rip), %rsi      # 0xc29b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
cmpl $0x3, %r14d
jb 0x524f
movq 0x20813(%rip), %rdi     # 0x25a08
leaq 0x709f(%rip), %rsi      # 0xc29b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
jmp 0x526c
cmpl $0x0, 0xcfaa(%rip)      # 0x121b8
je 0x528b
callq 0x3014
movq 0x207ec(%rip), %rcx     # 0x25a08
leaq 0x8491(%rip), %rdi      # 0xd6b4
movl $0x3, %esi
movl $0x1, %edx
callq 0x2300
movq 0x207cf(%rip), %rcx     # 0x25a08
leaq 0x8474(%rip), %rdi      # 0xd6b4
movl $0x3, %esi
movl $0x1, %edx
callq 0x2300
movq 0x207b2(%rip), %rcx     # 0x25a08
leaq 0x8457(%rip), %rdi      # 0xd6b4
movl $0x3, %esi
movl $0x1, %edx
callq 0x2300
movq 0x20795(%rip), %rdi     # 0x25a08
leaq 0x7497(%rip), %rsi      # 0xc711
leaq 0x1fc1f(%rip), %rdx     # 0x24ea0
movl %r14d, %ecx
xorl %eax, %eax
callq 0x2210
addl %r14d, 0xf4a2(%rip)     # 0x14734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7445(%rip), %rdi      # 0xc6f2
xorl %eax, %eax
callq 0x2e72
jmp 0x52c4
leaq 0x7419(%rip), %rdi      # 0xc6d6
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ListSizeInfo
char *ListSizeInfo(char *p)
{
   int i;
   p += strlen(p);

   if (!ModuleStart) return p;
   if (ListOn && !Pass)
   {
      i = AddressIndex(ModuleStart);
      if (i >= 0)
      {
         fprintf(lf,"              %s",Line);
         fprintf(lf," ;%5d [%s]",pc-ModuleStart,lab[i].Name);
         ModuleStart = 0;
      }
      fprintf(lf,"\n");
   }
   return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
movl 0x7fe89(%rip), %eax     # 0x85170
testl %eax, %eax
je 0x5395
cmpl $0x0, 0xcec2(%rip)      # 0x121b8
je 0x5395
cmpl $0x0, 0x20715(%rip)     # 0x25a18
jne 0x5395
movslq 0x20724(%rip), %rcx     # 0x25a34
testq %rcx, %rcx
jle 0x5384
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %r15d, %r15d
leaq 0x20719(%rip), %r12     # 0x25a40
cmpl %eax, 0xc(%r15,%r12)
je 0x5339
addq $0x30, %r15
cmpq %r15, %rcx
jne 0x5327
jmp 0x5384
movq 0x206c8(%rip), %rdi     # 0x25a08
leaq 0x73da(%rip), %rsi      # 0xc721
leaq 0x1fb52(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq 0x206ac(%rip), %rdi     # 0x25a08
movl 0xf3d2(%rip), %edx      # 0x14734
subl 0x7fe08(%rip), %edx     # 0x85170
movq (%r15,%r12), %rcx
leaq 0x73bf(%rip), %rsi      # 0xc732
xorl %eax, %eax
callq 0x2210
movl $0x0, 0x7fdec(%rip)     # 0x85170
movq 0x2067d(%rip), %rsi     # 0x25a08
movl $0xa, %edi
callq 0x21a0
addq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: IncludeFile
char *IncludeFile(char *p)
{
   size_t l,f;;
   char FileName[256];
   char *fp;
   p = NeedChar(p,'"');
   if (!p)
   {
      ErrorMsg("Missing quoted filename after INCLUDE\n");
      exit(1);
   }
   fp = FileName;
   ++p;
   while (*p != 0 && *p != '"') *fp++ = *p++;
   *fp = 0;
   if (df) fprintf(df,"fopen %s\n",FileName);
   if (IncludeLevel >= 99)
   {
      ErrorMsg("Too many includes nested ( >= 99)\n");
      exit(1);
   }
   sf = fopen(FileName,"r");
   if (!sf)
   {
      f = strlen(FileName);
      l = strlen(Ipa);
      if (l)
      {
         memmove(FileName+l,FileName,f+1);
         memmove(FileName,Ipa,l);
         sf = fopen(FileName,"r");
      }
      if (!sf)
      {
         printf("Could not open include file <%s>\n",FileName);
         exit(1);
      }
   }
   IncludeStack[IncludeLevel].LiNo = LiNo;
   IncludeStack[++IncludeLevel].fp = sf;
   IncludeStack[IncludeLevel].Src = (char *)StrNDup(FileName,strlen(FileName));
   PrintLine();
   LiNo = 0;
   return p+1; // skip quote after filename
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
cmpb $0x0, (%rdi)
je 0x5519
movq %rdi, %rbx
callq 0x2320
movq (%rax), %rax
incq %rbx
movb -0x1(%rbx), %cl
movsbq %cl, %rdx
incq %rbx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x53ca
cmpb $0x22, %cl
jne 0x5519
movq %rsp, %rax
movzbl -0x1(%rbx), %ecx
testl %ecx, %ecx
je 0x53fe
cmpl $0x22, %ecx
je 0x53fe
movb %cl, (%rax)
incq %rax
incq %rbx
jmp 0x53e7
movb $0x0, (%rax)
movq 0x20608(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x541e
leaq 0x7350(%rip), %rsi      # 0xc764
movq %rsp, %rdx
xorl %eax, %eax
callq 0x2210
cmpl $0x63, 0x205db(%rip)    # 0x25a00
jge 0x5522
leaq 0x7908(%rip), %rsi      # 0xcd3a
movq %rsp, %rdi
callq 0x22b0
movq %rax, 0x7fd37(%rip)     # 0x85178
testq %rax, %rax
jne 0x54aa
leaq 0x7fd33(%rip), %rdi     # 0x85180
callq 0x2110
testq %rax, %rax
je 0x553a
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2110
leaq (%rsp,%r14), %rdi
leaq 0x1(%rax), %rdx
movq %r15, %rsi
callq 0x22a0
leaq 0x7fd00(%rip), %rsi     # 0x85180
movq %r15, %rdi
movq %r14, %rdx
callq 0x2250
leaq 0x78a8(%rip), %rsi      # 0xcd3a
movq %r15, %rdi
callq 0x22b0
movq %rax, 0x7fcd7(%rip)     # 0x85178
testq %rax, %rax
je 0x553a
movl 0x1f8a8(%rip), %ecx     # 0x24d58
movslq 0x20549(%rip), %rdx     # 0x25a00
leaq (%rdx,%rdx,2), %rsi
leaq 0x1fbde(%rip), %r15     # 0x250a0
movl %ecx, 0x8(%r15,%rsi,8)
leal 0x1(%rdx), %ecx
movl %ecx, 0x20530(%rip)     # 0x25a00
movq %rax, 0x18(%r15,%rsi,8)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2110
movq %r14, %rdi
movl %eax, %esi
callq 0x2878
movslq 0x2050f(%rip), %rcx     # 0x25a00
leaq (%rcx,%rcx,2), %rcx
movq %rax, 0x10(%r15,%rcx,8)
callq 0x314b
movl $0x0, 0x1f84f(%rip)     # 0x24d58
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
leaq 0x721d(%rip), %rdi      # 0xc73d
jmp 0x5529
leaq 0x7245(%rip), %rdi      # 0xc76e
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
leaq 0x7250(%rip), %rdi      # 0xc791
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2130
jmp 0x5530
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseBSSData
char *ParseBSSData(char *p)
{
   int m;

   p = ExtractValue(p,&m);
   if (m < 1 || m > 32767)
   {
      ErrorMsg("Illegal BSS size %d\n",m);
      exit(1);
   }
   if (ListOn && !Pass)
      fprintf(lf,"%4.4x             %s\n",bss,Line);
   bss += m;
   return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
movq %rbx, %rsi
callq 0x352f
movq %rax, %r14
movl (%rbx), %ebx
movl $0xffff8000, %eax       # imm = 0xFFFF8000
leal (%rbx,%rax), %ecx
cmpl %eax, %ecx
jbe 0x5ae8
cmpl $0x0, 0xc70e(%rip)      # 0x121b8
je 0x5ad7
cmpl $0x0, 0x1ff65(%rip)     # 0x25a18
jne 0x5ad7
movq 0x1ff4c(%rip), %rdi     # 0x25a08
movl 0x1ff6e(%rip), %edx     # 0x25a30
leaq 0x6ed6(%rip), %rsi      # 0xc99f
leaq 0x1f3d0(%rip), %rcx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
addl %ebx, 0x1ff53(%rip)     # 0x25a30
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6e9b(%rip), %rdi      # 0xc98a
movl %ebx, %esi
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseCPUData
char *ParseCPUData(char *p)
{
   p = SkipSpace(p);
   if (*p == '=') ++p;
   p = EvalOperand(p,&CPU,0);
   if (CPU == 6809)
   {
      DimOp = DIMOP_6809;
      RegisterNames = Register_6809;
   }
   else if (CPU == 6309)
   {
      DimOp = DIMOP_6309;
      RegisterNames = Register_6309;
   }
   else
   {
      ErrorMsg("Unknown CPU %d - use 6809 or 6309\n",CPU);
      exit(1);
   }
   if (ListOn && !Pass)
   {
      PrintLiNo();
      fprintf(lf,"%4d              %s\n",CPU,Line);
   }
   return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x5b30
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x5b16
xorl %edi, %edi
cmpb $0x3d, %cl
sete %dil
jmp 0x5b32
xorl %edi, %edi
addq %rbx, %rdi
leaq 0xc674(%rip), %rsi      # 0x121b0
xorl %edx, %edx
callq 0x3e17
movq %rax, %rbx
movl 0xc664(%rip), %edx      # 0x121b0
cmpl $0x1a99, %edx           # imm = 0x1A99
je 0x5b6e
cmpl $0x18a5, %edx           # imm = 0x18A5
jne 0x5be4
leaq 0xea59(%rip), %rax      # 0x145c0
movl $0xe6, %ecx
jmp 0x5b7a
leaq 0xeacb(%rip), %rax      # 0x14640
movl $0x8b, %ecx
movl %ecx, 0xea30(%rip)      # 0x145b0
movq %rax, 0xeb39(%rip)      # 0x146c0
cmpl $0x0, 0xc62a(%rip)      # 0x121b8
je 0x5bdf
cmpl $0x0, 0x1fe81(%rip)     # 0x25a18
jne 0x5bdf
cmpl $0x0, 0x1f1bc(%rip)     # 0x24d5c
je 0x5bc3
movq 0x1fe5f(%rip), %rdi     # 0x25a08
movl 0x1f1a9(%rip), %edx     # 0x24d58
leaq 0x66b4(%rip), %rsi      # 0xc26a
xorl %eax, %eax
callq 0x2210
movl 0xc5ed(%rip), %edx      # 0x121b0
movq 0x1fe3e(%rip), %rdi     # 0x25a08
leaq 0x6e07(%rip), %rsi      # 0xc9d8
leaq 0x1f2c8(%rip), %rcx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
leaq 0x6dca(%rip), %rdi      # 0xc9b5
movl %edx, %esi
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseOnOff
char *ParseOnOff(char *p, int *v)
{
   p = SkipSpace(p);
        if (*p == '1') *v = 1;
   else if (*p == '0') *v = 0;
   else if (!StrNCaseCmp(p,"ON" ,2)) *v = 1;
   else if (!StrNCaseCmp(p,"OFF",3)) *v = 0;

   else
   {
      ErrorMsg("Unknown option\n");
      exit(1);
   }
   if (ListOn && !Pass)
   {
      PrintLiNo();
      fprintf(lf,"                  %s\n",Line);
   }
   return p + strlen(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movsbq (%rdi), %r15
testq %r15, %r15
je 0x5c3f
callq 0x2320
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
je 0x5c2c
movsbq 0x1(%rbx), %r15
incq %rbx
jmp 0x5c1a
cmpb $0x31, %r15b
je 0x5c89
movzbl %r15b, %eax
cmpl $0x30, %eax
jne 0x5c3f
xorl %ecx, %ecx
jmp 0x5c8e
leaq 0x6da7(%rip), %rsi      # 0xc9ed
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2c53
testl %eax, %eax
je 0x5c89
leaq 0x6d92(%rip), %rsi      # 0xc9f0
movq %rbx, %rdi
movl $0x3, %edx
callq 0x2c53
xorl %ecx, %ecx
testl %eax, %eax
je 0x5c8e
leaq 0x6d7c(%rip), %rdi      # 0xc9f4
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
movl $0x1, %ecx
movl %ecx, (%r14)
cmpl $0x0, 0xc520(%rip)      # 0x121b8
je 0x5ce3
cmpl $0x0, 0x1fd77(%rip)     # 0x25a18
jne 0x5ce3
cmpl $0x0, 0x1f0b2(%rip)     # 0x24d5c
je 0x5cc7
movq 0x1fd55(%rip), %rdi     # 0x25a08
movl 0x1f09f(%rip), %edx     # 0x24d58
leaq 0x65aa(%rip), %rsi      # 0xc26a
xorl %eax, %eax
callq 0x2210
movq 0x1fd3a(%rip), %rdi     # 0x25a08
leaq 0x65aa(%rip), %rsi      # 0xc27f
leaq 0x1f1c4(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseBitData
char *ParseBitData(char *p)
{
   int i,v;

   v = 0;
   for (i=0 ; i < 8 ; ++i)
   {
      v <<= 1;
      p = SkipSpace(p+1);
      if (*p == '*') v |= 1;
      else if (*p != '.')
      {
         ErrorMsg("use only '*' for 1 and '.' for 0 in BITS statement\n");
         exit(1);
      }
   }
   if (ListOn && !Pass)
   {
      PrintPC();
      PutByte(pc,v);
      fprintf(lf," %2.2x           ",v);
      fprintf(lf,"%s\n",Line);
   }
   ++pc;
   return p + strlen(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %r14d, %r14d
movsbq 0x1(%rbx), %r15
testq %r15, %r15
je 0x5dc7
incq %rbx
callq 0x2320
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
je 0x5d2e
movsbq 0x1(%rbx), %r15
incq %rbx
jmp 0x5d1c
addl %ebp, %ebp
cmpb $0x2e, %r15b
je 0x5d46
movzbl %r15b, %eax
cmpl $0x2a, %eax
jne 0x5dc7
orl $0x1, %ebp
incl %r14d
cmpl $0x8, %r14d
jne 0x5d03
cmpl $0x0, 0xc462(%rip)      # 0x121b8
je 0x5dab
cmpl $0x0, 0x1fcb9(%rip)     # 0x25a18
jne 0x5dab
callq 0x3014
movslq 0xe9c7(%rip), %rax      # 0x14734
leaq 0xeedc(%rip), %rcx      # 0x14c50
movb %bpl, (%rax,%rcx)
movq 0x1fc89(%rip), %rdi     # 0x25a08
leaq 0x6cb2(%rip), %rsi      # 0xca38
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movq 0x1fc72(%rip), %rdi     # 0x25a08
leaq 0x64f4(%rip), %rsi      # 0xc291
leaq 0x1f0fc(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
incl 0xe983(%rip)            # 0x14734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6c36(%rip), %rdi      # 0xca04
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseCmapData
char *ParseCmapData(char *p)
{
   int i,v,scanline;

   v = 0;
   if (*p >= '0' && *p < '8') scanline = *p - '0';
   else                       scanline = -1;

   for (i=0 ; i < 8 ; ++i)
   {
      v <<= 1;
      p = SkipSpace(p+1);
      if (*p == '*') v |= 1;
      else if (*p != '.')
      {
         ErrorMsg("use only '*' for 1 and '.' for 0 in CMAP statement\n");
         exit(1);
      }
   }
   if (!Pass)
   {
      if (ListOn) PrintPC();
      if (scanline < 0) PutByte(pc,v);
      else PutByte(pc+2*scanline-7,v);
      if (ListOn)
      {
         fprintf(lf," %2.2x       ",v);
         fprintf(lf,"%s\n",Line);
      }
   }
   ++pc;
   return p + strlen(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %al
movl %eax, %ecx
andb $-0x8, %cl
addb $-0x30, %al
cmpb $0x30, %cl
movzbl %al, %eax
movl $0xff, %r14d
cmovel %eax, %r14d
xorl %ebp, %ebp
xorl %r15d, %r15d
movsbq 0x1(%rbx), %r12
testq %r12, %r12
je 0x5ee5
incq %rbx
callq 0x2320
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
je 0x5e33
movsbq 0x1(%rbx), %r12
incq %rbx
jmp 0x5e21
addl %ebp, %ebp
cmpb $0x2e, %r12b
je 0x5e4b
movzbl %r12b, %eax
cmpl $0x2a, %eax
jne 0x5ee5
orl $0x1, %ebp
incl %r15d
cmpl $0x8, %r15d
jne 0x5e08
cmpl $0x0, 0x1fbbd(%rip)     # 0x25a18
jne 0x5ecb
cmpl $0x0, 0xc354(%rip)      # 0x121b8
je 0x5e6b
callq 0x3014
xorl %eax, %eax
testb %r14b, %r14b
movzbl %r14b, %ecx
leal -0x7(%rcx,%rcx), %ecx
cmovsl %eax, %ecx
addl 0xe8b3(%rip), %ecx      # 0x14734
movslq %ecx, %rax
leaq 0xedc5(%rip), %rcx      # 0x14c50
movb %bpl, (%rax,%rcx)
cmpl $0x0, 0xc322(%rip)      # 0x121b8
je 0x5ecb
movq 0x1fb69(%rip), %rdi     # 0x25a08
leaq 0x6bd8(%rip), %rsi      # 0xca7e
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movq 0x1fb52(%rip), %rdi     # 0x25a08
leaq 0x63d4(%rip), %rsi      # 0xc291
leaq 0x1efdc(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
incl 0xe863(%rip)            # 0x14734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6b5e(%rip), %rdi      # 0xca4a
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ParseASCII
char *ParseASCII(char *p, unsigned char b[], int *l)
{
   char Delimiter;

   Delimiter = *p++;
   while (*p && *p != Delimiter && *l < ML-1)
   {
      if (*p == '\\') // special character CR, LF, NULL
      {
         ++p;
              if (*p == 'r') b[*l] = 13; // return
         else if (*p == 'f') b[*l] = 12; // form feed
         else if (*p == 'n') b[*l] = 10; // new line
         else if (*p == 't') b[*l] =  9; // tab
         else if (*p == 'a') b[*l] =  7; // alert
         else if (*p == 'e') b[*l] = 27; // escape
         else if (*p == '0') b[*l] =  0; // zero
         else if (*p == 'b') b[*l] = 29; // bold colour
         else if (*p == 's') b[*l] = 28; // standard colour
         else b[*l] = *p;
         ++(*l);
         ++p;
      }
      else
      {
         b[(*l)++] = *p++;
      }
   }
   if (*p == Delimiter) ++p;
   if (*p == '^')
   {
      b[(*l)-1] |= 0x80; // Set bit 7 of last char
      ++p;
   }
   return p;
}

// Assembly:
leaq 0x1(%rdi), %rcx
movb (%rdi), %al
movb 0x1(%rdi), %r9b
testb %r9b, %r9b
sete %dil
cmpb %al, %r9b
sete %r8b
orb %r8b, %dil
testb $0x1, %dil
jne 0x5fc5
leaq 0x6197(%rip), %rdi      # 0xc0c0
movslq (%rdx), %r8
cmpq $0xfe, %r8
jg 0x5fc2
leaq 0x1(%rcx), %r10
cmpb $0x5c, %r9b
jne 0x5f63
movb (%r10), %r9b
movzbl %r9b, %r10d
leal -0x61(%r10), %r11d
cmpl $0x13, %r11d
ja 0x5f72
movslq (%rdi,%r11,4), %r10
addq %rdi, %r10
jmpq *%r10
movb $0x7, %r9b
jmp 0x5f9e
leal 0x1(%r8), %ecx
movl %ecx, (%rdx)
movb %r9b, (%rsi,%r8)
movq %r10, %rcx
jmp 0x5fa8
cmpl $0x30, %r10d
jne 0x5f9e
xorl %r9d, %r9d
jmp 0x5f9e
movb $0x9, %r9b
jmp 0x5f9e
movb $0x1c, %r9b
jmp 0x5f9e
movb $0x1b, %r9b
jmp 0x5f9e
movb $0x1d, %r9b
jmp 0x5f9e
movb $0xa, %r9b
jmp 0x5f9e
movb $0xc, %r9b
jmp 0x5f9e
movb $0xd, %r9b
movb %r9b, (%rsi,%r8)
incl (%rdx)
addq $0x2, %rcx
movb (%rcx), %r9b
cmpb %al, %r9b
sete %r8b
testb %r9b, %r9b
je 0x5fc5
cmpb %al, %r9b
jne 0x5f29
jmp 0x5fc5
xorl %r8d, %r8d
movzbl %r8b, %edi
leaq (%rcx,%rdi), %rax
cmpb $0x5e, (%rcx,%rdi)
jne 0x5fde
movslq (%rdx), %rcx
orb $-0x80, -0x1(%rsi,%rcx)
incq %rax
retq