LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x22
popq %rsi
callq 0x2f15
testq %rax, %rax
je 0x4bd7
movq %rax, %rbx
addq $0x2, %rbx
movq %rsp, %rax
movzbl -0x1(%rbx), %ecx
testl %ecx, %ecx
je 0x4abf
cmpl $0x22, %ecx
je 0x4abf
movb %cl, (%rax)
incq %rax
incq %rbx
jmp 0x4aa8
movb $0x0, (%rax)
movq 0x1ff47(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x4adf
leaq 0x6c1f(%rip), %rsi      # 0xb6f4
movq %rsp, %rdx
xorl %eax, %eax
callq 0x2210
cmpl $0x63, 0x1ff1a(%rip)    # 0x24a00
jge 0x4be0
leaq 0x71d7(%rip), %rsi      # 0xbcca
movq %rsp, %rdi
callq 0x22b0
movq %rax, 0x7f676(%rip)     # 0x84178
testq %rax, %rax
jne 0x4b6b
leaq 0x7f672(%rip), %rdi     # 0x84180
callq 0x2110
testq %rax, %rax
je 0x4bf0
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 0x7f63f(%rip), %rsi     # 0x84180
movq %r15, %rdi
movq %r14, %rdx
callq 0x2250
leaq 0x7177(%rip), %rsi      # 0xbcca
movq %r15, %rdi
callq 0x22b0
movq %rax, 0x7f616(%rip)     # 0x84178
testq %rax, %rax
je 0x4bf0
movl 0x1f1e7(%rip), %ecx     # 0x23d58
movslq 0x1fe88(%rip), %rdx     # 0x24a00
imulq $0x18, %rdx, %rsi
leaq 0x1f51d(%rip), %r15     # 0x240a0
movl %ecx, 0x8(%rsi,%r15)
leal 0x1(%rdx), %ecx
movl %ecx, 0x1fe6f(%rip)     # 0x24a00
movq %rax, 0x18(%rsi,%r15)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2110
movq %r14, %rdi
movl %eax, %esi
callq 0x258f
movslq 0x1fe4e(%rip), %rcx     # 0x24a00
imulq $0x18, %rcx, %rcx
movq %rax, 0x10(%rcx,%r15)
callq 0x2d99
andl $0x0, 0x1f191(%rip)     # 0x23d58
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6aef(%rip), %rdi      # 0xb6cd
jmp 0x4be7
leaq 0x6b17(%rip), %rdi      # 0xb6fe
xorl %eax, %eax
callq 0x2af7
jmp 0x4c01
leaq 0x6b2a(%rip), %rdi      # 0xb721
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2130
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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 0x3040
movq %rax, %r14
movl (%rbx), %ebx
movl $0xffff8000, %eax       # imm = 0xFFFF8000
leal (%rbx,%rax), %ecx
cmpl %eax, %ecx
jbe 0x50ee
cmpl $0x0, 0xc108(%rip)      # 0x111b8
je 0x50dd
cmpl $0x0, 0x1f95f(%rip)     # 0x24a18
jne 0x50dd
movq 0x1f946(%rip), %rdi     # 0x24a08
movl 0x1f968(%rip), %edx     # 0x24a30
leaq 0x6860(%rip), %rsi      # 0xb92f
leaq 0x1edca(%rip), %rcx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
addl %ebx, 0x1f94d(%rip)     # 0x24a30
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6825(%rip), %rdi      # 0xb91a
movl %ebx, %esi
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x2675
xorl %edi, %edi
cmpb $0x3d, (%rax)
sete %dil
addq %rax, %rdi
leaq 0xc091(%rip), %rsi      # 0x111b0
xorl %edx, %edx
callq 0x37d5
movq %rax, %rbx
movl 0xc081(%rip), %esi      # 0x111b0
cmpl $0x1a99, %esi           # imm = 0x1A99
je 0x514d
cmpl $0x18a5, %esi           # imm = 0x18A5
jne 0x51a4
leaq 0xe47a(%rip), %rax      # 0x135c0
movl $0xe6, %ecx
jmp 0x5159
leaq 0xe4ec(%rip), %rax      # 0x13640
movl $0x8b, %ecx
movl %ecx, 0xe451(%rip)      # 0x135b0
movq %rax, 0xe55a(%rip)      # 0x136c0
cmpl $0x0, 0xc04b(%rip)      # 0x111b8
je 0x519f
cmpl $0x0, 0x1f8a2(%rip)     # 0x24a18
jne 0x519f
callq 0x2c67
movq 0x1f884(%rip), %rdi     # 0x24a08
movl 0xc026(%rip), %edx      # 0x111b0
leaq 0x67d7(%rip), %rsi      # 0xb968
leaq 0x1ed08(%rip), %rcx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
leaq 0x679a(%rip), %rdi      # 0xb945
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x2675
movq %rax, %rbx
movzbl (%rax), %eax
pushq $0x1
popq %rbp
cmpl $0x31, %eax
je 0x520b
cmpl $0x30, %eax
jne 0x51dd
xorl %ebp, %ebp
jmp 0x520b
leaq 0x6799(%rip), %rsi      # 0xb97d
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x291a
testl %eax, %eax
je 0x520b
leaq 0x6786(%rip), %rsi      # 0xb980
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x291a
xorl %ebp, %ebp
testl %eax, %eax
jne 0x5251
movl %ebp, (%r14)
cmpl $0x0, 0xbfa3(%rip)      # 0x111b8
je 0x5241
cmpl $0x0, 0x1f7fa(%rip)     # 0x24a18
jne 0x5241
callq 0x2c67
movq 0x1f7dc(%rip), %rdi     # 0x24a08
leaq 0x5fdc(%rip), %rsi      # 0xb20f
leaq 0x1ec66(%rip), %rdx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x672c(%rip), %rdi      # 0xb984
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
pushq $0x8
popq %r14
subl $0x1, %r14d
jb 0x529c
addl %ebp, %ebp
incq %rbx
movq %rbx, %rdi
callq 0x2675
movq %rax, %rbx
movzbl (%rax), %eax
cmpl $0x2e, %eax
je 0x5274
cmpl $0x2a, %eax
jne 0x530e
orl $0x1, %ebp
jmp 0x5274
cmpl $0x0, 0xbf15(%rip)      # 0x111b8
je 0x52f8
cmpl $0x0, 0x1f76c(%rip)     # 0x24a18
jne 0x52f8
callq 0x2c8c
movslq 0xe47a(%rip), %rax      # 0x13734
leaq 0xe98f(%rip), %rcx      # 0x13c50
movb %bpl, (%rax,%rcx)
movq 0x1f73c(%rip), %rdi     # 0x24a08
leaq 0x66f5(%rip), %rsi      # 0xb9c8
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movq 0x1f725(%rip), %rdi     # 0x24a08
leaq 0x5f37(%rip), %rsi      # 0xb221
leaq 0x1ebaf(%rip), %rdx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
incl 0xe436(%rip)            # 0x13734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x667f(%rip), %rdi      # 0xb994
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
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
pushq $0x8
popq %r15
subl $0x1, %r15d
jb 0x5379
addl %ebp, %ebp
incq %rbx
movq %rbx, %rdi
callq 0x2675
movq %rax, %rbx
movzbl (%rax), %eax
cmpl $0x2e, %eax
je 0x534d
cmpl $0x2a, %eax
jne 0x540c
orl $0x1, %ebp
jmp 0x534d
cmpl $0x0, 0x1f698(%rip)     # 0x24a18
jne 0x53f0
cmpl $0x0, 0xbe2f(%rip)      # 0x111b8
je 0x5390
callq 0x2c8c
xorl %eax, %eax
testb %r14b, %r14b
movzbl %r14b, %ecx
leal -0x7(%rcx,%rcx), %ecx
cmovsl %eax, %ecx
addl 0xe38e(%rip), %ecx      # 0x13734
movslq %ecx, %rax
leaq 0xe8a0(%rip), %rcx      # 0x13c50
movb %bpl, (%rax,%rcx)
cmpl $0x0, 0xbdfd(%rip)      # 0x111b8
je 0x53f0
movq 0x1f644(%rip), %rdi     # 0x24a08
leaq 0x6643(%rip), %rsi      # 0xba0e
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movq 0x1f62d(%rip), %rdi     # 0x24a08
leaq 0x5e3f(%rip), %rsi      # 0xb221
leaq 0x1eab7(%rip), %rdx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
incl 0xe33e(%rip)            # 0x13734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x65c7(%rip), %rdi      # 0xb9da
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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:
movb (%rdi), %al
incq %rdi
leaq 0x5c22(%rip), %rcx      # 0xb050
movb (%rdi), %r9b
cmpb %al, %r9b
sete %r8b
testb %r9b, %r9b
je 0x54cd
cmpb %al, %r9b
je 0x54cd
movslq (%rdx), %r8
cmpq $0xfe, %r8
jg 0x54ca
leaq 0x1(%rdi), %r10
cmpb $0x5c, %r9b
jne 0x5480
movb (%r10), %r9b
movzbl %r9b, %r10d
leal -0x61(%r10), %r11d
cmpl $0x13, %r11d
ja 0x548f
movslq (%rcx,%r11,4), %r10
addq %rcx, %r10
jmpq *%r10
movb $0x7, %r9b
jmp 0x54bb
leal 0x1(%r8), %edi
movl %edi, (%rdx)
movb %r9b, (%rsi,%r8)
movq %r10, %rdi
jmp 0x542e
cmpl $0x30, %r10d
jne 0x54bb
xorl %r9d, %r9d
jmp 0x54bb
movb $0x9, %r9b
jmp 0x54bb
movb $0x1c, %r9b
jmp 0x54bb
movb $0x1b, %r9b
jmp 0x54bb
movb $0x1d, %r9b
jmp 0x54bb
movb $0xa, %r9b
jmp 0x54bb
movb $0xc, %r9b
jmp 0x54bb
movb $0xd, %r9b
movb %r9b, (%rsi,%r8)
incl (%rdx)
addq $0x2, %rdi
jmp 0x542e
xorl %r8d, %r8d
movzbl %r8b, %ecx
leaq (%rdi,%rcx), %rax
cmpb $0x5e, (%rdi,%rcx)
jne 0x54e6
movslq (%rdx), %rcx
orb $-0x80, -0x1(%rsi,%rcx)
incq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: Parsebit5Data
char *Parsebit5Data(char *p)
{
   char c;
   int i,v;

   p = SkipSpace(p);
   if (strlen(p) < 7 || p[0] != '"' || p[6] != '"')
   {
      ErrorMsg("Need 5 character string\n");
      ErrorLine(p);
      exit(1);
   }

   // pack 5 characters into 20 bit

   // '?' ->  0
   // ' ' ->  1
   // 'A' ->  2
   // 'Z' -> 27
   // '2' -> 28
   // '3' -> 29

   v = 0;
   for (i=4 ; i > 0 ; --i)
   {
      c = p[i];
      if (c == ' ') c = 0x40;
      if (c == '2') c = 'Z'+1;
      if (c == '3') c = 'Z'+2;
      if (c < '?' || c > 'Z'+2)
      {
         ErrorMsg("illegal character\n");
         ErrorLine(p);
         exit(1);
      }
      v = (v << 5) | (c - '?');
   }
        if (p[5] == 'C') v |= (1 << 20);
   else if (p[5] == 'D') v |= (2 << 20);
   else if (p[5] == 'R') v |= (3 << 20);
   else if (p[5] == 'W') v |= (4 << 20);

   if (!Pass)
   {
      if (ListOn) fprintf(lf," %6.6x       %s\n",v,Line);
      for (i=2 ; i >= 0 ; --i)
      {
         PutByte(pc+i,v);
         v >>= 8;
      }
   }
   pc += 3;
   return p+7;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x2675
movq %rax, %rbx
movq %rax, %rdi
callq 0x2110
cmpq $0x7, %rax
jb 0x5998
cmpb $0x22, (%rbx)
jne 0x5998
cmpb $0x22, 0x6(%rbx)
jne 0x5998
xorl %ebp, %ebp
pushq $0x4
popq %rdi
pushq $0x40
popq %rax
pushq $0x5b
popq %rcx
pushq $0x5c
popq %rdx
movl %edi, %esi
subl $0x1, %esi
jb 0x58cf
movl %edi, %edi
movzbl (%rbx,%rdi), %edi
cmpb $0x20, %dil
cmovel %eax, %edi
movl %ecx, %r8d
cmpb $0x32, %dil
je 0x58a6
movl %edi, %r8d
movl %edx, %edi
cmpb $0x33, %r8b
je 0x58b1
movl %r8d, %edi
leal -0x5d(%rdi), %r8d
cmpb $-0x1f, %r8b
jbe 0x597a
movzbl %dil, %edi
shll $0x5, %ebp
addl $-0x3f, %edi
orl %edi, %ebp
movl %esi, %edi
jmp 0x5888
movzbl 0x5(%rbx), %eax
cmpl $0x57, %eax
je 0x58ff
cmpl $0x44, %eax
je 0x58ef
cmpl $0x52, %eax
je 0x58f7
cmpl $0x43, %eax
jne 0x5905
orl $0x100000, %ebp         # imm = 0x100000
jmp 0x5905
orl $0x200000, %ebp         # imm = 0x200000
jmp 0x5905
orl $0x300000, %ebp         # imm = 0x300000
jmp 0x5905
orl $0x400000, %ebp         # imm = 0x400000
cmpl $0x0, 0x1f10c(%rip)     # 0x24a18
je 0x592b
movl 0xde20(%rip), %eax      # 0x13734
addl $0x3, %eax
movl %eax, 0xde17(%rip)      # 0x13734
addq $0x7, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x0, 0xb886(%rip)      # 0x111b8
je 0x5952
movq 0x1f0cd(%rip), %rdi     # 0x24a08
leaq 0x616c(%rip), %rsi      # 0xbaae
leaq 0x1e557(%rip), %rcx     # 0x23ea0
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movl 0xdddc(%rip), %eax      # 0x13734
movslq %eax, %rcx
pushq $0x2
popq %rdx
leaq 0xe2eb(%rip), %rsi      # 0x13c50
testq %rdx, %rdx
js 0x5914
leaq (%rcx,%rdx), %rdi
movb %bpl, (%rsi,%rdi)
sarl $0x8, %ebp
decq %rdx
jmp 0x5965
leaq 0x611a(%rip), %rdi      # 0xba9b
xorl %eax, %eax
callq 0x2af7
movq %rbx, %rdi
callq 0x2a71
pushq $0x1
popq %rdi
callq 0x22f0
leaq 0x60e3(%rip), %rdi      # 0xba82
jmp 0x5981
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ParseSubroutine
char *ParseSubroutine(char *p)
{
   p = SkipSpace(p);
   DefineLabel(p,&ModuleStart,'M');
   strcpy(Scope,Label);
   if (!Pass && ListOn)
   {
      fprintf(lf,"              %s\n",Line);
   }
   return p;
}

// Assembly:
pushq %rbx
callq 0x2675
movq %rax, %rbx
leaq 0x7e7bf(%rip), %rsi     # 0x84170
pushq $0x4d
popq %rdx
movq %rax, %rdi
callq 0x32ce
leaq 0x1e3dd(%rip), %rdi     # 0x23da0
leaq 0x7e596(%rip), %rsi     # 0x83f60
callq 0x2090
cmpl $0x0, 0x1f042(%rip)     # 0x24a18
jne 0x59fd
cmpl $0x0, 0xb7d9(%rip)      # 0x111b8
je 0x59fd
movq 0x1f020(%rip), %rdi     # 0x24a08
leaq 0x5824(%rip), %rsi      # 0xb213
leaq 0x1e4aa(%rip), %rdx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: EndSub
char *EndSub(char *p)
{
   if (!Pass && ListOn)
   {
      PrintPC();
      p = ListSizeInfo(p);
   }
   Scope[0] = 0;
   ModuleStart = 0;
   return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x1f00b(%rip)     # 0x24a18
jne 0x5a28
cmpl $0x0, 0xb7a2(%rip)      # 0x111b8
je 0x5a28
callq 0x2c8c
movq %rbx, %rdi
callq 0x49d8
movq %rax, %rbx
movb $0x0, 0x1e371(%rip)     # 0x23da0
andl $0x0, 0x7e73a(%rip)     # 0x84170
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ps_align
char *ps_align(char *p)
{
   int a,dal,fill;

   dal  = 0;                  // data align = false
   p = SkipSpace(p);
   if (*p == '*') ++p;        // PC align
   if (*p == '&')
   {
      dal = 1;                // data align
      ++p;
   }
   if (dal) fill = Preset;
   else     fill = 0x12  ;    // NOP

   p = AlignFill(p,&a,&fill);

   if (dal)
   {
      a = (a - bss % a) % a;
      if (df) fprintf(df,"Data align %4.4x - %4.4x fill %2.2x\n",bss,bss+a,fill);
      while (a--) ROM[bss++] = fill;
   }
   else
   {
      a = (a - pc  % a) % a;
      if (df) fprintf(df,"Code align %4.4x - %4.4x fill %2.2x\n",pc,pc+a,fill);
      while (a--) ROM[pc++]  = fill;
   }
   PrintPCLine();
   return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
callq 0x2675
xorl %ecx, %ecx
cmpb $0x2a, (%rax)
sete %cl
leaq (%rax,%rcx), %rdi
movb (%rax,%rcx), %r12b
xorl %eax, %eax
cmpb $0x26, %r12b
sete %al
jne 0x5bd3
movl 0x7e8e7(%rip), %ecx     # 0x844b8
jmp 0x5bd6
pushq $0x12
popq %rcx
addq %rax, %rdi
leaq 0x8(%rsp), %r14
movl %ecx, (%r14)
leaq 0xc(%rsp), %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x4412
movq %rax, %rbx
movl (%r15), %ecx
movq 0x1ee12(%rip), %rdi     # 0x24a10
movl (%r14), %ebp
cmpb $0x26, %r12b
jne 0x5c74
movl 0x1ee22(%rip), %r8d     # 0x24a30
movl %r8d, %eax
cltd
idivl %ecx
movl %ecx, %eax
subl %edx, %eax
cltd
idivl %ecx
movl %edx, %r14d
testq %rdi, %rdi
je 0x5c42
leal (%r14,%r8), %ecx
leaq 0x5e91(%rip), %rsi      # 0xbabf
movl %r8d, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x2210
movl 0x1edee(%rip), %r8d     # 0x24a30
movslq %r8d, %rax
leal 0x1(%rax), %ecx
movl %r14d, %edx
xorl %esi, %esi
leaq 0xdffc(%rip), %rdi      # 0x13c50
cmpl %esi, %edx
je 0x5cdd
leal (%rcx,%rsi), %r8d
movl %r8d, 0x1edc9(%rip)     # 0x24a30
leaq (%rax,%rsi), %r8
movb %bpl, (%rdi,%r8)
incq %rsi
jmp 0x5c54
movl 0xdab9(%rip), %r8d      # 0x13734
movl %r8d, %eax
cltd
idivl %ecx
movl %ecx, %eax
subl %edx, %eax
cltd
idivl %ecx
movl %edx, %r14d
testq %rdi, %rdi
je 0x5caf
leal (%r14,%r8), %ecx
leaq 0x5e49(%rip), %rsi      # 0xbae4
movl %r8d, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x2210
movl 0xda85(%rip), %r8d      # 0x13734
movslq %r8d, %rax
leal 0x1(%rax), %ecx
movl %r14d, %edx
xorl %esi, %esi
leaq 0xdf8f(%rip), %rdi      # 0x13c50
cmpl %esi, %edx
je 0x5cdd
leal (%rcx,%rsi), %r8d
movl %r8d, 0xda64(%rip)      # 0x13734
leaq (%rax,%rsi), %r8
movb %bpl, (%rdi,%r8)
incq %rsi
jmp 0x5cc1
callq 0x2dcf
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: SetPC
char *SetPC(char *p)
{
   p = NeedChar(p,'=');
   if (p) return ps_org(p+1);

   ++ErrNum;
   ErrorMsg("Setting PC with \"* = address\" syntax error\n");
   exit(1);
}

// Assembly:
pushq %rax
pushq $0x3d
popq %rsi
callq 0x2f15
testq %rax, %rax
je 0x5d26
incq %rax
movq %rax, %rdi
popq %rax
jmp 0x5cf2
incl 0x1ed00(%rip)           # 0x24a2c
leaq 0x5dd6(%rip), %rdi      # 0xbb09
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ps_rmb
char *ps_rmb(char *p)
{
   int size;
   p = ExtractValue(p,&size);
   if (size < 0)
   {
      ErrorMsg("Only theoretical physicists are allowed to reserve "
               "a negative amount of space: %d bytes\n", size);
      exit(1);
   }
   PrintPCLine();
   pc+=size;
   p += strlen(p);
   return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x3040
movl (%r14), %ebp
testl %ebp, %ebp
js 0x5d80
movq %rax, %rbx
callq 0x2dcf
addl %ebp, 0xd9c8(%rip)      # 0x13734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5dae(%rip), %rdi      # 0xbb35
movl %ebp, %esi
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ps_sect
char *ps_sect(char *p)
{
   char *q;

   q = StrMatch(p,"LOC=");
   if (q) q = EvalOperand(q+4,&pc,0);
   PrintPCLine();
   return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x5deb(%rip), %rsi      # 0xbb8e
callq 0x269d
testq %rax, %rax
je 0x5dc2
addq $0x4, %rax
leaq 0xd97c(%rip), %rsi      # 0x13734
movq %rax, %rdi
xorl %edx, %edx
callq 0x37d5
callq 0x2dcf
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ps_setdp
char *ps_setdp(char *p)
{
   p = ExtractValue(p,&DP);
   if (DP > 255) DP >>= 8;      // alternate DP assignment
   PrintByteLine(DP);
   return p;
}

// Assembly:
pushq %rbx
leaq 0x7e6e8(%rip), %rsi     # 0x844bc
callq 0x3040
movq %rax, %rbx
movl 0x7e6da(%rip), %edi     # 0x844bc
cmpl $0x100, %edi            # imm = 0x100
jl 0x5df3
shrl $0x8, %edi
movl %edi, 0x7e6c9(%rip)     # 0x844bc
callq 0x2e05
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: CheckPseudo
char *CheckPseudo(char *p)
{
   int i;

   p = SkipSpace(p);

   for (i=0 ; i < PSEUDOS ; ++i)
   if (!strcmpword(p,PseudoTab[i].keyword))
   {
      p = PseudoTab[i].foo(p+strlen(PseudoTab[i].keyword));
      if (pc > 0x10000)
      {
         ErrorMsg("Program counter overflow\n");
         ErrorLine(p);
         exit(1);
      }
      return NULL; // flag for pseudo op processed
   }
   return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x2675
movq %rax, %rbx
xorl %ecx, %ecx
leaq 0xdbfa(%rip), %r15      # 0x13a10
leaq 0x10(%rcx), %r12
cmpq $0x230, %r12            # imm = 0x230
je 0x5e5d
movq (%rcx,%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2994
movq %r12, %rcx
testl %eax, %eax
jne 0x5e16
movq -0x8(%r12,%r15), %r15
movq %r14, %rdi
callq 0x2110
addq %rax, %rbx
movq %rbx, %rdi
callq *%r15
cmpl $0x10001, 0xd8db(%rip)  # imm = 0x10001
jge 0x5e6c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x5dd1(%rip), %rdi      # 0xbc47
xorl %eax, %eax
callq 0x2af7
movq %rbx, %rdi
callq 0x2a71
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: RegisterSize
int RegisterSize(int n)
{
   char r;

   if (!StrNCaseCmp(Mat[n].Mne,"LDMD",4)) return 1;
   if (!StrNCaseCmp(Mat[n].Mne,"CWAI",4)) return 1;

   r = Mat[n].Mne[strlen(Mat[n].Mne)-1];

   if (r == 'A' || r == 'B' || r == 'C' || r == 'E' || r == 'F') return 1;
   if (r == 'D' || r == 'X' || r == 'Y' || r == 'W') return 2;
   if (r == 'S' || r == 'U') return 2;
   if (r == 'Q') return 4;

   ErrorMsg("Illegal register name [%c]\n",r);
   exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movslq %edi, %rax
imulq $0x28, %rax, %rax
leaq 0xafae(%rip), %rbx      # 0x111c0
addq %rax, %rbx
leaq 0x5b6f(%rip), %rsi      # 0xbd8b
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x291a
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x626f
leaq 0x5b5b(%rip), %rsi      # 0xbd90
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x291a
testl %eax, %eax
je 0x626f
movq %rbx, %rdi
callq 0x2110
movsbl -0x1(%rax,%rbx), %esi
leal -0x41(%rsi), %eax
cmpb $0x19, %al
jae 0x6278
movzbl %al, %eax
movl $0x1d5003f, %ecx        # imm = 0x1D5003F
btl %eax, %ecx
jae 0x6278
leaq 0x4e84(%rip), %rcx      # 0xb0f0
movl (%rcx,%rax,4), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5b16(%rip), %rdi      # 0xbd95
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ScanRegister
char *ScanRegister(char *p, int *v)
{
   int i;
   char *q;

   for (i=15 ; i >= 0 ; --i)
   {
      if (!StrNCaseCmp(RegisterNames[i],p,strlen(RegisterNames[i]))) break;
   }
   if (i < 0)
   {
      ErrorLine(p);
      ErrorMsg("Unknown register name or wrong CPU set\n");
      exit(1);
   }
   *v = i;
   q = p + strlen(RegisterNames[i]);
   q = SkipSpace(q);
   if (*q == ',') ++q;
   return q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0xf
popq %rbp
movq 0xd41a(%rip), %r12      # 0x136c0
testl %ebp, %ebp
js 0x62f7
movl %ebp, %eax
movq (%r12,%rax,8), %r15
movq %r15, %rdi
callq 0x2110
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x291a
testl %eax, %eax
je 0x62cd
decl %ebp
jmp 0x62a6
movl %ebp, (%r14)
movq %r15, %rdi
callq 0x2110
addq %rax, %rbx
movq %rbx, %rdi
callq 0x2675
xorl %ecx, %ecx
cmpb $0x2c, (%rax)
sete %cl
addq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x2a71
leaq 0x5aab(%rip), %rdi      # 0xbdb1
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: TFMRegister
char *TFMRegister(char *p, int *v)
{
   int i;

   for (i=4 ; i >= 0 ; --i)
   {
      if (RegisterNames[i][0] == toupper(*p)) break;
   }
   if (i < 0)
   {
      ErrorLine(p);
      ErrorMsg("Illegal register name for TFM or wrong CPU set\n");
      exit(1);
   }
   *v = i;
   return p+1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0xd399(%rip), %r15      # 0x136c0
callq 0x2030
movq (%rax), %rax
movsbq (%rbx), %rcx
movl (%rax,%rcx,4), %ecx
pushq $0x4
popq %rax
testl %eax, %eax
js 0x635d
movl %eax, %edx
movq (%r15,%rdx,8), %rdx
movsbl (%rdx), %edx
cmpl %edx, %ecx
je 0x634e
decl %eax
jmp 0x6339
movl %eax, (%r14)
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2a71
leaq 0x5a6d(%rip), %rdi      # 0xbdd9
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: OperandError
void OperandError(char *p)
{
   ++ErrNum;
   ErrorLine(p);
   ErrorMsg("Syntax error in operand\n");
   exit(1);
}

// Assembly:
pushq %rax
incl 0x1e6aa(%rip)           # 0x24a2c
callq 0x2a71
leaq 0x5a7b(%rip), %rdi      # 0xbe09
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: PostIndex
int PostIndex(int reg,char *p)
{
   switch(*p)
   {
      case 'x':
      case 'X': if (reg < 0) reg = 0x00; else OperandError(p); break;
      case 'y':
      case 'Y': if (reg < 0) reg = 0x20; else OperandError(p); break;
      case 'u':
      case 'U': if (reg < 0) reg = 0x40; else OperandError(p); break;
      case 's':
      case 'S': if (reg < 0) reg = 0x60; else OperandError(p); break;
      default : OperandError(p);
   }
   return reg;
}

// Assembly:
pushq %rax
movzbl (%rsi), %eax
leal -0x53(%rax), %ecx
cmpl $0x6, %ecx
jbe 0x63c1
addl $-0x73, %eax
cmpl $0x6, %eax
ja 0x63f2
leaq 0x4d04(%rip), %rcx      # 0xb0bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4cd8(%rip), %rax      # 0xb0a0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
testl %edi, %edi
jns 0x63f2
pushq $0x60
jmp 0x63ef
xorl %eax, %eax
testl %edi, %edi
js 0x63f0
jmp 0x63f2
testl %edi, %edi
jns 0x63f2
pushq $0x20
jmp 0x63ef
testl %edi, %edi
jns 0x63f2
pushq $0x40
popq %rax
popq %rcx
retq
movq %rsi, %rdi
callq 0x637b
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ScanPushList
int ScanPushList(char *p)
{
   int i,l,v;
   char *Reg;

   if (!strcmpword(p,"ALL")) return 0xff;
   v = 0;
   while (*p)
   {
      for (i=9 ; i >= 0 ; --i) // Scan DP before D
      {
         Reg = PushList[i].Reg;
         l = strlen(Reg);
         if (df) fprintf(df,"push list [%s] <%s>\n",p,Reg);
         if (!strcmpword(p,Reg)) break;
      }
      if (i < 0) OperandError(p);
      v |= PushList[i].Val;
      p = SkipSpace(p+l);
      if (*p != ',' && *p != 0) OperandError(p);
      if (*p == ',') ++p;
      p = SkipSpace(p);
   }
   return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x54b2(%rip), %rsi      # 0xbf0d
callq 0x2994
testl %eax, %eax
je 0x6b16
leaq 0xcc61(%rip), %rbp      # 0x136d0
xorl %ebx, %ebx
cmpb $0x0, (%r15)
je 0x6b1b
movl %ebx, 0x4(%rsp)
pushq $0x9
popq %r14
testl %r14d, %r14d
js 0x6b2c
movl %r14d, %ebx
leaq (,%rbx,8), %r13
addq %rbp, %r13
movq %r13, %rdi
callq 0x2110
movq %rax, %r12
movq 0x1df64(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x6ac5
leaq 0x5459(%rip), %rsi      # 0xbf11
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2210
movq %r15, %rdi
movq %r13, %rsi
callq 0x2994
decl %r14d
testl %eax, %eax
jne 0x6a83
movslq %r12d, %rax
addq %rax, %r15
movq %r15, %rdi
callq 0x2675
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x6af1
cmpl $0x2c, %ecx
jne 0x6b34
movl 0x4(%rsp), %edx
orl 0x4(%rbp,%rbx,8), %edx
movl %edx, %ebx
xorl %edx, %edx
cmpb $0x2c, %cl
sete %dl
addq %rdx, %rax
movq %rax, %rdi
callq 0x2675
movq %rax, %r15
jmp 0x6a71
movl $0xff, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x637b
movq %rax, %rdi
callq 0x637b
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ScanArguments
int ScanArguments(char *p, char *args, int ptr[], int nargs)
{
   int l,n;
   char sym[ML];

   if (df) fprintf(df,"Scan Args %d <%s>\n",nargs,p);
   n = 0;
   ptr[0] = 0;
   while (*p && n < nargs)
   {
      if (df) fprintf(df,"Arg #%d <%s>\n",n,p);
      p = SkipSpace(p);
      if (*p == ')') break; // end of list
      if (nargs == MAXARGS) p = GetSymbol(p,sym);
      else                  p = GetMacroArg(p,sym);
      l = strlen(sym);
      if (l) memmove(args+ptr[n],sym,l+1);
      else   args[ptr[n]] = 0;
      ++n;
      ptr[n] = ptr[n-1] + l + 1;
      p = SkipSpace(p);
      if (*p == ')') break; // end of list
      if (*p != ',' && n < nargs-1 && nargs < MAXARGS)
      {
         ++ErrNum;
         ErrorMsg("Syntax error in macro definition '%c'\n",*p);
         exit(1);
      }
      if (*p == ',') ++p;
   }
   return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq 0x1cdc6(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x7c62
leaq 0x46ca(%rip), %rsi      # 0xc320
movl %ebx, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2210
andl $0x0, (%r14)
leal -0x1(%rbx), %eax
movl %eax, 0xc(%rsp)
movslq %ebx, %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %r12
xorl %ebp, %ebp
cmpq 0x18(%rsp), %rbp
jge 0x7d59
cmpb $0x0, (%r13)
je 0x7d59
movq 0x1cd77(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x7cb1
leaq 0x468e(%rip), %rsi      # 0xc333
movl %ebp, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2210
movq %r13, %rdi
callq 0x2675
cmpb $0x29, (%rax)
je 0x7d59
movq %rax, %rdi
movq %r12, %rsi
cmpl $0xa, %ebx
jne 0x7cd4
callq 0x27d6
jmp 0x7cd9
callq 0x285c
movq %rax, %r13
movq %r12, %rdi
callq 0x2110
movq %rax, %r15
movslq (%r14,%rbp,4), %rdi
addq 0x10(%rsp), %rdi
testl %r15d, %r15d
je 0x7d07
movl %r15d, %eax
incl %eax
movslq %eax, %rdx
movq %r12, %rsi
callq 0x2250
jmp 0x7d0a
movb $0x0, (%rdi)
leaq 0x1(%rbp), %r12
movl (%r14,%rbp,4), %eax
addl %r15d, %eax
incl %eax
movl %eax, 0x4(%r14,%rbp,4)
movq %r13, %rdi
callq 0x2675
movq %rax, %r13
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0x7d40
cmpl $0x29, %eax
je 0x7d57
cmpl $0x9, %ebx
jg 0x7d40
cmpl %r12d, 0xc(%rsp)
jg 0x7d6d
xorl %ecx, %ecx
cmpb $0x2c, %al
sete %cl
addq %rcx, %r13
movq %r12, %rbp
leaq 0x20(%rsp), %r12
jmp 0x7c7c
incl %ebp
movl %ebp, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl 0x1ccb9(%rip)           # 0x24a2c
movsbl (%r13), %esi
leaq 0x45c2(%rip), %rdi      # 0xc341
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ScanArgs
int ScanArgs(char *p, char *args, int ptr[])
{
   int l,n;
   char sym[ML];

   n = 0;
   ptr[0] = 0;
   // if (df) fprintf(df,"Inside ScanArgs: <%s>\n",p);
   while (*p && n < 10)
   {
      p = SkipSpace(p);
      if (*p == ';') break; // comment
      p = NextSymbol(p,sym);
      l = strlen(sym);
      // if (df) fprintf(df,"ScanSym:<%s>[%d]\n",sym,l);
      if (l) memmove(args+ptr[n],sym,l+1);
      else   args[ptr[n]] = 0;
      ++n;
      ptr[n] = ptr[n-1] + l + 1;
      p = SkipSpace(p);
      if (*p != ',') break; // end of list
      ++p; // skip comma
   }
   return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %rbx
andl $0x0, (%rdx)
movq %rsi, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
cmpq $0x9, %rbp
ja 0x7e28
cmpb $0x0, (%rdi)
je 0x7e28
callq 0x2675
cmpb $0x3b, (%rax)
je 0x7e28
movq %rax, %rdi
movq %r15, %rsi
callq 0x288d
movq %rax, %r12
movq %r15, %rdi
callq 0x2110
movq %rax, %r13
movslq (%rbx,%rbp,4), %rdi
addq 0x8(%rsp), %rdi
testl %r13d, %r13d
je 0x7dff
movl %r13d, %eax
incl %eax
movslq %eax, %rdx
movq %r15, %rsi
callq 0x2250
jmp 0x7e02
movb $0x0, (%rdi)
leaq 0x1(%rbp), %r14
movl (%rbx,%rbp,4), %eax
addl %r13d, %eax
incl %eax
movl %eax, 0x4(%rbx,%rbp,4)
movq %r12, %rdi
callq 0x2675
leaq 0x1(%rax), %rdi
cmpb $0x2c, (%rax)
movq %r14, %rbp
je 0x7db1
jmp 0x7e2b
movq %rbp, %r14
movl %r14d, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: MacroInfo
void MacroInfo(int n)
{
   fprintf(df,"-----------------\n");
   fprintf(df,"Name: %s\n",Mac[n].Name);
   fprintf(df,"Args: %d\n",Mac[n].Narg);
   fprintf(df,"Cola: %d\n",Mac[n].Cola);
   fprintf(df,"Type: %d\n",Mac[n].Type);
   fprintf(df,"Body: <<<%s>>>\n",Mac[n].Body);
   fprintf(df,"-----------------\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movq 0x1cbbc(%rip), %rcx     # 0x24a10
leaq 0x450d(%rip), %rbx      # 0xc368
pushq $0x12
popq %r14
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2300
movq 0x1cb98(%rip), %rdi     # 0x24a10
movslq %ebp, %r12
shlq $0x5, %r12
leaq 0x7a7ca(%rip), %r13     # 0x82650
movq (%r12,%r13), %rdx
leaq 0x44ea(%rip), %rsi      # 0xc37b
xorl %eax, %eax
callq 0x2210
movq 0x1cb71(%rip), %rdi     # 0x24a10
movl 0x10(%r12,%r13), %edx
leaq 0x44da(%rip), %rsi      # 0xc385
xorl %eax, %eax
callq 0x2210
movq 0x1cb57(%rip), %rdi     # 0x24a10
movl 0x14(%r12,%r13), %edx
leaq 0x44ca(%rip), %rsi      # 0xc38f
xorl %eax, %eax
callq 0x2210
movq 0x1cb3d(%rip), %rdi     # 0x24a10
movl 0x18(%r12,%r13), %edx
leaq 0x44ba(%rip), %rsi      # 0xc399
xorl %eax, %eax
callq 0x2210
movq 0x1cb23(%rip), %rdi     # 0x24a10
movq 0x8(%r12,%r13), %rdx
leaq 0x44aa(%rip), %rsi      # 0xc3a3
xorl %eax, %eax
callq 0x2210
movq 0x1cb09(%rip), %rcx     # 0x24a10
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2300
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ExpandMacro
int ExpandMacro(char *m)
{
   int j,an;
   char *p;
   char Macro[ML];

   j = MacroIndex(m);
   if (j < 0) return j;
   if (df) fprintf(df,"\nExpanding [%s] phase %d\n",Mac[j].Name,Pass);

   p = NextSymbol(m,Macro);
   p = SkipSpace(p);
   if (*p == '(') ++p;  // parenthesis are optional

   ExtractOpText(p);    // separate arguments from comment
   p  = OpText;
   an = ScanArguments(p,MacArgs,ArgPtr,Mac[j].Narg);

   if (an != Mac[j].Narg)
   {
      ++ErrNum;
      ErrorMsg("Wrong # of arguments in [%s] called (%d) defined (%d)\n",
            Macro,an,Mac[j].Narg);
      exit(1);
   }
   ++MacLev;
   MacPtr[MacLev] = Mac[j].Body;
   if (df) fprintf(df,"Macro Level:%d\n",MacLev);
   if (df) fprintf(df,"Macro Body :<<<%s>>>\n",Mac[j].Body);

   if (!Pass)
   {
      Mac[j].Cola = m - Line;
      PrintLine();
   }
   return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %r14
callq 0x3141
movl %eax, %ebx
testl %eax, %eax
js 0x859b
movq 0x1c576(%rip), %rdi     # 0x24a10
movl %ebx, %r12d
testq %rdi, %rdi
je 0x84c8
movq %r12, %rax
shlq $0x5, %rax
leaq 0x7a1a0(%rip), %rcx     # 0x82650
movq (%rax,%rcx), %rdx
movl 0x1c55e(%rip), %ecx     # 0x24a18
leaq 0x3f90(%rip), %rsi      # 0xc451
xorl %eax, %eax
callq 0x2210
movq %rsp, %rsi
movq %r14, %rdi
callq 0x288d
movq %rax, %rdi
callq 0x2675
xorl %edi, %edi
cmpb $0x28, (%rax)
sete %dil
addq %rax, %rdi
callq 0x31b3
shlq $0x5, %r12
leaq 0x7a159(%rip), %r15     # 0x82650
movl 0x10(%r12,%r15), %ecx
leaq 0x1ba9d(%rip), %rdi     # 0x23fa0
leaq 0x7e2d6(%rip), %rsi     # 0x867e0
leaq 0x7e3cf(%rip), %rdx     # 0x868e0
callq 0x7c25
movl 0x10(%r12,%r15), %ecx
cmpl %ecx, %eax
jne 0x85ac
addq %r12, %r15
movslq 0x7e3db(%rip), %rax     # 0x86908
leaq 0x1(%rax), %rdx
movl %edx, 0x7e3d1(%rip)     # 0x86908
movq 0x8(%r15), %rcx
leaq 0x7e3ce(%rip), %rsi     # 0x86910
movq %rcx, 0x8(%rsi,%rax,8)
movq 0x1c4c2(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x857f
leaq 0x3f48(%rip), %rsi      # 0xc4a2
xorl %eax, %eax
callq 0x2210
movq 0x1c4a8(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x857f
movq 0x8(%r15), %rdx
leaq 0x3f3a(%rip), %rsi      # 0xc4b2
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x1c492(%rip)     # 0x24a18
jne 0x859b
leaq 0x1b911(%rip), %rax     # 0x23ea0
subl %eax, %r14d
movl %r14d, 0x14(%r15)
callq 0x2d99
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
incl 0x1c47a(%rip)           # 0x24a2c
leaq 0x3eb2(%rip), %rdi      # 0xc46b
movq %rsp, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: NextMacLine
void NextMacLine(char *w)
{
   int i;
   char *r;

   if (df) fprintf(df,"Next Macro Line:%s\n",w);

   // do not count macro expansion lines

   --LiNo;

   // check for end of macro body

   while (MacLev > 0 && *MacPtr[MacLev] == 0) --MacLev;

   if (df) fprintf(df,"MacPtr[%d] = {{%s}}\n",MacLev,MacPtr[MacLev]);

   if (MacPtr[MacLev] && *MacPtr[MacLev])
   {
      while (*MacPtr[MacLev] &&
             *MacPtr[MacLev] != '\n')
      {
         if (*MacPtr[MacLev] == CHAMAC)
         {
            i = *(++MacPtr[MacLev]) - '0';
            r = MacArgs + ArgPtr[i];
            while (*r) *w++ = *r++;
            ++MacPtr[MacLev];
         }
         else *w++ = *MacPtr[MacLev]++;
      }
      if (*MacPtr[MacLev] == '\n') ++MacPtr[MacLev];
   }
   *w = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c435(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x85f1
leaq 0x3ee1(%rip), %rsi      # 0xc4c8
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2210
decl 0x1b761(%rip)           # 0x23d58
movslq 0x7e30a(%rip), %rdx     # 0x86908
leaq 0x7e30b(%rip), %r14     # 0x86910
leaq (%r14,%rdx,8), %rax
testl %edx, %edx
jle 0x8626
movl %edx, %ecx
movq (%r14,%rcx,8), %rcx
cmpb $0x0, (%rcx)
jne 0x8626
decl %edx
movl %edx, 0x7e2e8(%rip)     # 0x86908
addq $-0x8, %rax
jmp 0x8609
movq 0x1c3e3(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x8649
movq (%rax), %rcx
leaq 0x3ea0(%rip), %rsi      # 0xc4dc
xorl %eax, %eax
callq 0x2210
movl 0x7e2bf(%rip), %edx     # 0x86908
movslq %edx, %rax
movq (%r14,%rax,8), %rsi
testq %rsi, %rsi
je 0x86ee
movb (%rsi), %dil
testb %dil, %dil
je 0x86ee
leaq 0x7e274(%rip), %rax     # 0x868e0
leaq 0x7e16d(%rip), %rcx     # 0x867e0
movslq %edx, %rdx
cmpb $0x60, %dil
je 0x86a5
movzbl %dil, %edi
testl %edi, %edi
je 0x86ee
cmpl $0xa, %edi
je 0x86e7
leaq 0x1(%rsi), %rdi
movq %rdi, (%r14,%rdx,8)
movb (%rsi), %dl
movb %dl, (%rbx)
incq %rbx
movslq 0x7e269(%rip), %rdx     # 0x86908
movq (%r14,%rdx,8), %rsi
jmp 0x86e2
leaq 0x1(%rsi), %rdi
movq %rdi, (%r14,%rdx,8)
movsbq 0x1(%rsi), %rdx
movslq -0xc0(%rax,%rdx,4), %rdx
addq %rcx, %rdx
movb (%rdx), %sil
testb %sil, %sil
je 0x86d0
incq %rdx
movb %sil, (%rbx)
incq %rbx
jmp 0x86bd
movslq 0x7e231(%rip), %rdx     # 0x86908
movq (%r14,%rdx,8), %rsi
incq %rsi
movq %rsi, (%r14,%rdx,8)
movb (%rsi), %dil
jmp 0x8673
incq %rsi
movq %rsi, (%r14,%rdx,8)
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: Phase1Listing
void Phase1Listing(void)
{
   fprintf(df,"%5d %4.4x",LiNo,pc);
   if (Label[0]) fprintf(df,"  Label:[%s]{%4.4x}",Label,lab[LabelIndex(Label)].Address);
   if (Comment[0]) fprintf(df,"  %s",Comment);
   fprintf(df,"\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1bdeb(%rip), %rdi     # 0x24a10
movl 0x1b12d(%rip), %edx     # 0x23d58
movl 0xab03(%rip), %ecx      # 0x13734
leaq 0x3919(%rip), %rsi      # 0xc551
xorl %eax, %eax
callq 0x2210
cmpb $0x0, 0x7b31a(%rip)     # 0x83f60
je 0x8c83
movq 0x1bdc1(%rip), %rbx     # 0x24a10
leaq 0x7b30a(%rip), %r14     # 0x83f60
movq %r14, %rdi
callq 0x30cc
cltq
imulq $0x30, %rax, %rax
leaq 0x1bdd5(%rip), %rcx     # 0x24a40
movl 0xc(%rax,%rcx), %ecx
leaq 0x38e5(%rip), %rsi      # 0xc55b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
cmpb $0x0, 0x7e2c6(%rip)     # 0x86f50
je 0x8ca8
movq 0x1bd7d(%rip), %rdi     # 0x24a10
leaq 0x2a23(%rip), %rsi      # 0xb6bd
leaq 0x7e2af(%rip), %rdx     # 0x86f50
xorl %eax, %eax
callq 0x2210
movq 0x1bd61(%rip), %rsi     # 0x24a10
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: CloseInclude
int CloseInclude(void)
{
   const char *msg = "Close INCLUDE file";

   PrintLiNo();
   if (!Pass)
   {
      if (ListOn) fprintf(lf,";                       closed INCLUDE file %s\n",
            IncludeStack[IncludeLevel].Src);
      if (ferror(lf)) AssertFileOp(NULL, msg);
   }
   if (fclose(sf)) AssertFileOp(NULL, msg);
   free(IncludeStack[IncludeLevel].Src);
   sf = IncludeStack[--IncludeLevel].fp;
   LiNo = IncludeStack[IncludeLevel].LiNo;
   fgets(Line,sizeof(Line),sf);
   ForcedEnd = 0;
   return feof(sf);
}

// Assembly:
pushq %rbx
callq 0x2c67
cmpl $0x0, 0x1bd4d(%rip)     # 0x24a18
jne 0x8d20
cmpl $0x0, 0x84e4(%rip)      # 0x111b8
je 0x8d02
movq 0x1bd2b(%rip), %rdi     # 0x24a08
movslq 0x1bd1c(%rip), %rax     # 0x24a00
imulq $0x18, %rax, %rax
leaq 0x1b3b1(%rip), %rcx     # 0x240a0
movq 0x10(%rax,%rcx), %rdx
leaq 0x3887(%rip), %rsi      # 0xc582
xorl %eax, %eax
callq 0x2210
movq 0x1bcff(%rip), %rdi     # 0x24a08
callq 0x20b0
testl %eax, %eax
je 0x8d20
leaq 0x3856(%rip), %rsi      # 0xc56f
xorl %edi, %edi
callq 0x2575
movq 0x7b451(%rip), %rdi     # 0x84178
callq 0x2100
testl %eax, %eax
je 0x8d3e
leaq 0x3838(%rip), %rsi      # 0xc56f
xorl %edi, %edi
callq 0x2575
movslq 0x1bcbb(%rip), %rax     # 0x24a00
imulq $0x18, %rax, %rax
leaq 0x1b350(%rip), %rbx     # 0x240a0
movq 0x10(%rax,%rbx), %rdi
callq 0x2040
movslq 0x1bc9f(%rip), %rax     # 0x24a00
decq %rax
movl %eax, 0x1bc96(%rip)     # 0x24a00
imulq $0x18, %rax, %rax
movq (%rax,%rbx), %rdx
movq %rdx, 0x7b3ff(%rip)     # 0x84178
movl 0x8(%rax,%rbx), %eax
movl %eax, 0x1afd5(%rip)     # 0x23d58
leaq 0x1b116(%rip), %rdi     # 0x23ea0
movl $0x100, %esi            # imm = 0x100
callq 0x21c0
andl $0x0, 0x7b715(%rip)     # 0x844b0
movq 0x7b3d6(%rip), %rdi     # 0x84178
popq %rbx
jmp 0x2230
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: Phase1
void Phase1(void)
{
   int i,l,Eof;

   ForcedEnd = 0;
   Changes   = 0;
   for (i=0 ; i < 11 ; ++i) minlab[i] = UNDEF;

   rewind(sf);
   fgets(Line,sizeof(Line),sf);
   Eof = feof(sf);
   while (!Eof || IncludeLevel > 0)
   {
      ++LiNo; ++TotalLiNo;
      l = strlen(Line);
      if (l && Line[l-1] == 10) Line[--l] = 0; // Remove linefeed
      if (l && Line[l-1] == 13) Line[--l] = 0; // Remove return
      ParseLine(Line);
      if (MacLev)
      {
         NextMacLine(Line);
         if (df) fprintf(df,"Macro: %s\n",Line);
      }
      else
      {
         fgets(Line,sizeof(Line),sf);
      }
      Eof = feof(sf) || ForcedEnd;;
      if (Eof && IncludeLevel > 0) Eof = CloseInclude();
   }
}

// Assembly:
andl $0x0, 0x7b701(%rip)     # 0x844b0
andl $0x0, 0x7b2aa(%rip)     # 0x84060
xorl %eax, %eax
leaq 0x7b751(%rip), %rcx     # 0x84510
cmpq $0x2c, %rax
je 0x8dd2
movl $0xff0000, (%rax,%rcx)  # imm = 0xFF0000
addq $0x4, %rax
jmp 0x8dbf
pushq %r14
pushq %rbx
pushq %rax
movq 0x7b39b(%rip), %rdi     # 0x84178
callq 0x2140
movq 0x7b38f(%rip), %rdx     # 0x84178
leaq 0x1b0b0(%rip), %rbx     # 0x23ea0
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x21c0
movq 0x7b374(%rip), %rdi     # 0x84178
callq 0x2230
movl 0x1bbf1(%rip), %ecx     # 0x24a00
leaq 0x379c(%rip), %r14      # 0xc5b2
testl %eax, %eax
je 0x8e22
testl %ecx, %ecx
jle 0x8eea
incl 0x1af30(%rip)           # 0x23d58
incl 0x1af32(%rip)           # 0x23d60
movq %rbx, %rdi
callq 0x2110
testl %eax, %eax
je 0x8e63
movl %eax, %ecx
decl %ecx
movslq %ecx, %rcx
cmpb $0xa, (%rcx,%rbx)
jne 0x8e55
cltq
movb $0x0, -0x1(%rax,%rbx)
decq %rax
testl %eax, %eax
je 0x8e63
cltq
cmpb $0xd, -0x1(%rax,%rbx)
jne 0x8e63
movb $0x0, -0x1(%rax,%rbx)
movq %rbx, %rdi
callq 0x86f9
cmpl $0x0, 0x7da96(%rip)     # 0x86908
je 0x8e97
movq %rbx, %rdi
callq 0x85cd
movq 0x1bb8d(%rip), %rdi     # 0x24a10
testq %rdi, %rdi
je 0x8eab
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2210
jmp 0x8eab
movq 0x7b2da(%rip), %rdx     # 0x84178
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x21c0
movq 0x7b2c6(%rip), %rdi     # 0x84178
callq 0x2230
movl %eax, %ecx
xorl %eax, %eax
orl 0x7b5ef(%rip), %ecx     # 0x844b0
setne %al
movl 0x1bb36(%rip), %ecx     # 0x24a00
testl %ecx, %ecx
setg %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x8e16
callq 0x8cbe
movl 0x1bb1b(%rip), %ecx     # 0x24a00
jmp 0x8e16
addq $0x8, %rsp
popq %rbx
popq %r14
retq