LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x21833(%rip), %r12     # 0x25a34
cmpq $0x1f3f, %r12           # imm = 0x1F3F
jge 0x4360
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
movslq 0x10390(%rip), %r13     # 0x145b0
testq %r13, %r13
jle 0x4248
leaq 0xdf94(%rip), %r15      # 0x121c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2be5
testl %eax, %eax
je 0x4345
addq $0x28, %r15
decq %r13
jne 0x422c
xorl %r15d, %r15d
leaq 0x107be(%rip), %r13     # 0x14a10
movq (%r15,%r13), %rsi
movq %rbx, %rdi
callq 0x2be5
testl %eax, %eax
je 0x433c
addq $0x10, %r15
cmpq $0x220, %r15            # imm = 0x220
jne 0x4252
leaq (%r12,%r12,2), %rax
shlq $0x4, %rax
leaq 0x217be(%rip), %r15     # 0x25a40
movl $0xff0000, 0xc(%rax,%r15) # imm = 0xFF0000
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2878
movslq 0x21797(%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 0x2176a(%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 0x2173c(%rip), %rax     # 0x25a34
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq %rbx, 0x28(%rax,%r15)
movl 0x20a4d(%rip), %ecx     # 0x24d58
movq 0x20(%rax,%r15), %rax
movl %ecx, (%rax)
movslq 0x2171b(%rip), %rax     # 0x25a34
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x28(%rax,%r15), %rax
movl $0x0, (%rax)
incl 0x21702(%rip)           # 0x25a34
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x89d5(%rip), %rdi      # 0xcd18
jmp 0x434c
leaq 0x8999(%rip), %rdi      # 0xcce5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
incl 0x216c6(%rip)           # 0x25a2c
leaq 0x7fc4(%rip), %rdi      # 0xc331
movl $0x1f40, %esi           # imm = 0x1F40
xorl %eax, %eax
callq 0x2e63
jmp 0x4356
// File: /workspace/github_c_makefile_star2_O1/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 0x2aa4
movq %rax, %rbx
movslq 0x21693(%rip), %r13     # 0x25a34
testq %r13, %r13
jle 0x43cf
leaq 0x216a3(%rip), %rbp     # 0x25a50
xorl %r15d, %r15d
movq %rsp, %r12
movq -0x10(%rbp), %rsi
movq %r12, %rdi
callq 0x3559
testl %eax, %eax
je 0x43e0
incq %r15
addq $0x30, %rbp
cmpq %r15, %r13
jne 0x43b3
movq %rsp, %rdi
callq 0x41f1
movl $0xff0000, (%r14)       # imm = 0xFF0000
jmp 0x43ee
movl (%rbp), %eax
movl %eax, (%r14)
movl %r15d, %edi
callq 0x40d3
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_O1/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 0x4441
addl $-0x30, %eax
jmp 0x4461
leal -0x41(%rax), %ecx
cmpb $0x5, %cl
ja 0x444e
addl $-0x37, %eax
jmp 0x4461
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 0x4472
addl $-0x30, %ecx
jmp 0x4492
leal -0x41(%rcx), %edx
cmpb $0x5, %dl
ja 0x447f
addl $-0x37, %ecx
jmp 0x4492
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_O1/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), %rcx
xorl %eax, %eax
movsbq (%rbx,%rax), %rdx
testb $0x10, 0x1(%rcx,%rdx,2)
je 0x4789
incq %rax
cmpq $0x5, %rax
jne 0x476f
movl $0x5, %eax
movl %eax, %eax
movzbl (%rbx,%rax), %eax
orl $0x20, %eax
cmpl $0x68, %eax
jne 0x47b7
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x10, %edx
callq 0x2200
movl %eax, (%r14)
movq (%r15), %rbx
incq %rbx
jmp 0x47e5
movq %rbx, %rdi
callq 0x22d0
movl %eax, (%r14)
callq 0x2320
movq (%rax), %rcx
decq %rbx
movsbq 0x1(%rbx), %rax
incq %rbx
movzwl (%rcx,%rax,2), %edx
btl $0xb, %edx
jb 0x47cd
btl $0xa, %edx
jb 0x47f2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movzbl %al, %eax
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0x4833
movabsq $0x3f0000003f, %rcx     # imm = 0x3F0000003F
btq %rax, %rcx
jae 0x4833
leaq 0x7ca4(%rip), %rdi      # 0xc4b8
xorl %eax, %eax
callq 0x2e63
incl 0x2120b(%rip)           # 0x25a2c
movq %rbx, %rdi
callq 0x2dcf
movl $0x1, %edi
callq 0x22f0
leaq 0x7cb3(%rip), %rdi      # 0xc4ed
jmp 0x4814
// File: /workspace/github_c_makefile_star2_O1/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 0x487c
cmpb $0x27, 0x1(%rdi)
jne 0x4850
cmpb $0x27, 0x3(%rdi)
jne 0x4898
cmpb $0x5c, %al
jne 0x487c
leaq 0x1(%rdi), %rcx
movzbl 0x1(%rdi), %eax
cmpl $0x64, %eax
jle 0x48a4
cmpl $0x65, %eax
je 0x48b5
movl $0xd, %edx
cmpl $0x72, %eax
je 0x48c3
cmpl $0x6e, %eax
jne 0x48c0
movl $0xa, %edx
jmp 0x48c3
incq %rdi
movl %eax, (%rsi)
movq %rdi, %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x4890
cmpl $0x27, %ecx
jne 0x48d3
cmpb $0x1, %cl
sbbq $-0x1, %rax
retq
movl $0x5c, (%rsi)
addq $0x2, %rdi
jmp 0x4881
cmpl $0x30, %eax
je 0x48bc
cmpl $0x61, %eax
jne 0x48c0
movl $0x7, %edx
jmp 0x48c3
movl $0x1b, %edx
jmp 0x48c3
xorl %edx, %edx
jmp 0x48c3
movsbl %al, %edx
movl %edx, (%rsi)
leaq 0x2(%rdi), %rax
cmpb $0x0, 0x1(%rdi)
cmoveq %rcx, %rax
jmp 0x4884
pushq %rax
incl 0x21152(%rip)           # 0x25a2c
leaq 0x7c33(%rip), %rdi      # 0xc514
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
movl $0x0, (%rsi)
xorl %eax, %eax
movsbl (%rbx,%rax), %ecx
cmpl $0x22, %ecx
je 0x4918
movl (%rsi), %edx
shll $0x8, %edx
orl %ecx, %edx
movl %edx, (%rsi)
incq %rax
cmpl $0x4, %eax
jne 0x48fe
addq %rax, %rbx
cmpb $0x22, (%rbx)
jne 0x4925
incq %rbx
jmp 0x4933
leaq 0x7c15(%rip), %rdi      # 0xc541
xorl %eax, %eax
callq 0x2e63
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x773c(%rip), %rdx      # 0xc080
movzbl (%rax), %edi
leal -0x2a(%rdi), %r8d
cmpl $0x7, %r8d
ja 0x4964
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
leal 0x1(,%rcx,2), %ecx
jmp 0x4969
cmpl $0x20, %edi
jne 0x497a
cmpl $0x30, %edi
je 0x4973
cmpl $0x2e, %edi
jne 0x4975
addl %ecx, %ecx
incq %rax
jmp 0x4944
movl %ecx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpb $0x5b, (%rdi)
movl $0x5d, %eax
movl $0x29, %ebx
cmovel %eax, %ebx
incq %rdi
xorl %edx, %edx
callq 0x3daa
movq %rax, %rdi
movl %ebx, %esi
callq 0x3342
testq %rax, %rax
je 0x49ce
incq %rax
popq %rbx
retq
xorl %edi, %edi
callq 0x2dcf
movzbl %bl, %esi
leaq 0x7b8c(%rip), %rdi      # 0xc56b
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x369b
movq %rax, %rbx
cmpb $0x0, 0x203e9(%rip)     # 0x24fa0
je 0x4bef
leaq 0x203e0(%rip), %rdi     # 0x24fa0
movq %r15, %rsi
xorl %edx, %edx
callq 0x3daa
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x4be6
cmpl $0x28, %ecx
jne 0x4c00
incq %rax
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3daa
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2dcf
leaq 0x7a22(%rip), %rdi      # 0xc620
jmp 0x4c0f
movq %rax, %rdi
callq 0x2dcf
leaq 0x7a3a(%rip), %rdi      # 0xc649
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3daa
movl (%rbx), %ebx
cmpq $0x10000, %rbx          # imm = 0x10000
jae 0x5244
movq %rax, %rdi
movl $0x28, %esi
callq 0x3342
testq %rax, %rax
je 0x5256
incq %rax
movq %rsp, %r15
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3daa
movq %rax, %r14
movzbl (%r15), %ebp
movl %ebp, (%r15)
cmpl $0x0, 0x208eb(%rip)     # 0x25a18
jne 0x5228
testq %rbx, %rbx
je 0x5153
movslq 0xf5f5(%rip), %rax      # 0x14734
leaq 0xfb0a(%rip), %rdi      # 0x14c50
addq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x2180
cmpl $0x0, 0xd05e(%rip)      # 0x121b8
je 0x5228
callq 0x3005
movq 0x2089c(%rip), %rcx     # 0x25a08
testq %rbx, %rbx
je 0x5186
leaq 0x7137(%rip), %rsi      # 0xc2af
movq %rcx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
jmp 0x519c
leaq 0x8541(%rip), %rdi      # 0xd6ce
movl $0x3, %esi
movl $0x1, %edx
callq 0x2300
movq 0x20865(%rip), %rcx     # 0x25a08
cmpl $0x2, %ebx
jl 0x51bd
leaq 0x7100(%rip), %rsi      # 0xc2af
movq %rcx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
jmp 0x51d3
leaq 0x850a(%rip), %rdi      # 0xd6ce
movl $0x3, %esi
movl $0x1, %edx
callq 0x2300
movq 0x2082e(%rip), %rcx     # 0x25a08
cmpl $0x3, %ebx
jl 0x51f4
leaq 0x70c9(%rip), %rsi      # 0xc2af
movq %rcx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
jmp 0x520a
leaq 0x84d3(%rip), %rdi      # 0xd6ce
movl $0x3, %esi
movl $0x1, %edx
callq 0x2300
movq 0x207f7(%rip), %rdi     # 0x25a08
leaq 0x750d(%rip), %rsi      # 0xc725
leaq 0x1fc81(%rip), %rdx     # 0x24ea0
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2210
addl %ebx, 0xf506(%rip)      # 0x14734
movq %r14, %rdi
callq 0x2110
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x749f(%rip), %rdi      # 0xc6ea
movl %ebx, %esi
xorl %eax, %eax
callq 0x2e63
jmp 0x5264
leaq 0x74a9(%rip), %rdi      # 0xc706
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
movl 0x7feed(%rip), %eax     # 0x85170
testl %eax, %eax
je 0x5344
cmpl $0x0, 0xcf26(%rip)      # 0x121b8
je 0x5344
cmpl $0x0, 0x20779(%rip)     # 0x25a18
jne 0x5344
movslq 0x20788(%rip), %rcx     # 0x25a34
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x52d3
leaq 0x2078f(%rip), %rsi     # 0x25a4c
xorl %edx, %edx
cmpl %eax, (%rsi)
je 0x52d1
incq %rdx
addq $0x30, %rsi
cmpq %rdx, %rcx
jne 0x52bf
jmp 0x52d3
movl %edx, %ebp
testl %ebp, %ebp
js 0x5333
movq 0x2072a(%rip), %rdi     # 0x25a08
leaq 0x7450(%rip), %rsi      # 0xc735
leaq 0x1fbb4(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq 0x2070e(%rip), %rdi     # 0x25a08
movl 0xf434(%rip), %edx      # 0x14734
subl 0x7fe6a(%rip), %edx     # 0x85170
movl %ebp, %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
leaq 0x20729(%rip), %rcx     # 0x25a40
movq (%rax,%rcx), %rcx
leaq 0x7424(%rip), %rsi      # 0xc746
xorl %eax, %eax
callq 0x2210
movl $0x0, 0x7fe3d(%rip)     # 0x85170
movq 0x206ce(%rip), %rsi     # 0x25a08
movl $0xa, %edi
callq 0x21a0
addq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x22, %esi
callq 0x3342
testq %rax, %rax
je 0x54b1
movq %rax, %rbx
addq $0x2, %rbx
movq %rsp, %rax
movzbl -0x1(%rbx), %ecx
testl %ecx, %ecx
je 0x538f
cmpl $0x22, %ecx
je 0x538f
movb %cl, (%rax)
incq %rax
incq %rbx
jmp 0x5378
movb $0x0, (%rax)
movq 0x20677(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x53af
leaq 0x73d3(%rip), %rsi      # 0xc778
movq %rsp, %rdx
xorl %eax, %eax
callq 0x2210
cmpl $0x63, 0x2064a(%rip)    # 0x25a00
jge 0x54ba
leaq 0x798b(%rip), %rsi      # 0xcd4e
movq %rsp, %rdi
callq 0x22b0
movq %rax, 0x7fda6(%rip)     # 0x85178
testq %rax, %rax
jne 0x543c
leaq 0x7fda2(%rip), %rdi     # 0x85180
callq 0x2110
testq %rax, %rax
je 0x542e
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 0x7fd73(%rip), %rsi     # 0x85180
movq %r15, %rdi
movq %r14, %rdx
callq 0x2250
leaq 0x792f(%rip), %rsi      # 0xcd4e
movq %r15, %rdi
callq 0x22b0
movq %rax, 0x7fd4a(%rip)     # 0x85178
cmpq $0x0, 0x7fd42(%rip)     # 0x85178
je 0x54d2
movl 0x1f916(%rip), %eax     # 0x24d58
movslq 0x205b7(%rip), %rcx     # 0x25a00
leaq (%rcx,%rcx,2), %rdx
leaq 0x1fc4c(%rip), %r15     # 0x250a0
movl %eax, 0x8(%r15,%rdx,8)
movq 0x7fd18(%rip), %rax     # 0x85178
incl %ecx
movl %ecx, 0x20598(%rip)     # 0x25a00
movq %rax, 0x18(%r15,%rdx,8)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2110
movq %r14, %rdi
movl %eax, %esi
callq 0x2878
movslq 0x20577(%rip), %rcx     # 0x25a00
leaq (%rcx,%rcx,2), %rcx
movq %rax, 0x10(%r15,%rcx,8)
callq 0x313c
movl $0x0, 0x1f8b7(%rip)     # 0x24d58
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7299(%rip), %rdi      # 0xc751
jmp 0x54c1
leaq 0x72c1(%rip), %rdi      # 0xc782
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
leaq 0x72cc(%rip), %rdi      # 0xc7a5
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2130
jmp 0x54c8
// File: /workspace/github_c_makefile_star2_O1/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 0x34ef
movq %rax, %r14
movl (%rbx), %ebx
movl $0xffff8000, %eax       # imm = 0xFFFF8000
leal (%rbx,%rax), %ecx
cmpl %eax, %ecx
jbe 0x59f5
cmpl $0x0, 0xc801(%rip)      # 0x121b8
je 0x59e4
cmpl $0x0, 0x20058(%rip)     # 0x25a18
jne 0x59e4
movq 0x2003f(%rip), %rdi     # 0x25a08
movl 0x20061(%rip), %edx     # 0x25a30
leaq 0x6fdd(%rip), %rsi      # 0xc9b3
leaq 0x1f4c3(%rip), %rcx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
addl %ebx, 0x20046(%rip)     # 0x25a30
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6fa2(%rip), %rdi      # 0xc99e
movl %ebx, %esi
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x5a32
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x5a23
xorl %edi, %edi
cmpb $0x3d, (%rbx)
sete %dil
addq %rbx, %rdi
leaq 0xc76b(%rip), %rsi      # 0x121b0
xorl %edx, %edx
callq 0x3daa
movq %rax, %rbx
movl 0xc75b(%rip), %esi      # 0x121b0
cmpl $0x1a99, %esi           # imm = 0x1A99
je 0x5a77
cmpl $0x18a5, %esi           # imm = 0x18A5
jne 0x5aed
leaq 0xeb50(%rip), %rax      # 0x145c0
movl $0xe6, %ecx
jmp 0x5a83
leaq 0xebc2(%rip), %rax      # 0x14640
movl $0x8b, %ecx
movl %ecx, 0xeb27(%rip)      # 0x145b0
movq %rax, 0xec30(%rip)      # 0x146c0
cmpl $0x0, 0xc721(%rip)      # 0x121b8
je 0x5ae8
cmpl $0x0, 0x1ff78(%rip)     # 0x25a18
jne 0x5ae8
cmpl $0x0, 0x1f2b3(%rip)     # 0x24d5c
je 0x5ac6
movq 0x1ff56(%rip), %rdi     # 0x25a08
movl 0x1f2a0(%rip), %edx     # 0x24d58
leaq 0x67bf(%rip), %rsi      # 0xc27e
xorl %eax, %eax
callq 0x2210
movq 0x1ff3b(%rip), %rdi     # 0x25a08
movl 0xc6dd(%rip), %edx      # 0x121b0
leaq 0x6f12(%rip), %rsi      # 0xc9ec
leaq 0x1f3bf(%rip), %rcx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
leaq 0x6ed5(%rip), %rdi      # 0xc9c9
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x5b2e
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x5b1f
movzbl (%rbx), %eax
movl $0x1, %ebp
cmpl $0x31, %eax
je 0x5b76
cmpl $0x30, %eax
jne 0x5b44
xorl %ebp, %ebp
jmp 0x5b76
leaq 0x6eb6(%rip), %rsi      # 0xca01
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2c50
testl %eax, %eax
je 0x5b76
leaq 0x6ea1(%rip), %rsi      # 0xca04
movq %rbx, %rdi
movl $0x3, %edx
callq 0x2c50
xorl %ebp, %ebp
testl %eax, %eax
jne 0x5bdb
movl %ebp, (%r14)
cmpl $0x0, 0xc638(%rip)      # 0x121b8
je 0x5bcb
cmpl $0x0, 0x1fe8f(%rip)     # 0x25a18
jne 0x5bcb
cmpl $0x0, 0x1f1ca(%rip)     # 0x24d5c
je 0x5baf
movq 0x1fe6d(%rip), %rdi     # 0x25a08
movl 0x1f1b7(%rip), %edx     # 0x24d58
leaq 0x66d6(%rip), %rsi      # 0xc27e
xorl %eax, %eax
callq 0x2210
movq 0x1fe52(%rip), %rdi     # 0x25a08
leaq 0x66d6(%rip), %rsi      # 0xc293
leaq 0x1f2dc(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6e26(%rip), %rdi      # 0xca08
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r14d, %r14d
cmpb $0x0, 0x1(%rbx)
je 0x5c1e
callq 0x2320
movq (%rax), %rax
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x5c0d
jmp 0x5c21
incq %rbx
addl %ebp, %ebp
movzbl (%rbx), %eax
cmpl $0x2e, %eax
je 0x5c33
cmpl $0x2a, %eax
jne 0x5cae
orl $0x1, %ebp
incl %r14d
cmpl $0x8, %r14d
jne 0x5bff
cmpl $0x0, 0xc575(%rip)      # 0x121b8
je 0x5c98
cmpl $0x0, 0x1fdcc(%rip)     # 0x25a18
jne 0x5c98
callq 0x3005
movslq 0xeada(%rip), %rax      # 0x14734
leaq 0xefef(%rip), %rcx      # 0x14c50
movb %bpl, (%rax,%rcx)
movq 0x1fd9c(%rip), %rdi     # 0x25a08
leaq 0x6dd9(%rip), %rsi      # 0xca4c
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movq 0x1fd85(%rip), %rdi     # 0x25a08
leaq 0x661b(%rip), %rsi      # 0xc2a5
leaq 0x1f20f(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
incl 0xea96(%rip)            # 0x14734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6d63(%rip), %rdi      # 0xca18
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r15d, %r15d
cmpb $0x0, 0x1(%rbx)
je 0x5d0d
callq 0x2320
movq (%rax), %rax
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x5cfc
jmp 0x5d10
incq %rbx
addl %ebp, %ebp
movzbl (%rbx), %eax
cmpl $0x2e, %eax
je 0x5d26
cmpl $0x2a, %eax
jne 0x5dc2
orl $0x1, %ebp
incl %r15d
cmpl $0x8, %r15d
jne 0x5cee
cmpl $0x0, 0x1fce2(%rip)     # 0x25a18
jne 0x5da6
cmpl $0x0, 0xc479(%rip)      # 0x121b8
je 0x5d46
callq 0x3005
xorl %eax, %eax
testb %r14b, %r14b
movzbl %r14b, %ecx
leal -0x7(%rcx,%rcx), %ecx
cmovsl %eax, %ecx
addl 0xe9d8(%rip), %ecx      # 0x14734
movslq %ecx, %rax
leaq 0xeeea(%rip), %rcx      # 0x14c50
movb %bpl, (%rax,%rcx)
cmpl $0x0, 0xc447(%rip)      # 0x121b8
je 0x5da6
movq 0x1fc8e(%rip), %rdi     # 0x25a08
leaq 0x6d11(%rip), %rsi      # 0xca92
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movq 0x1fc77(%rip), %rdi     # 0x25a08
leaq 0x650d(%rip), %rsi      # 0xc2a5
leaq 0x1f101(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
incl 0xe988(%rip)            # 0x14734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6c95(%rip), %rdi      # 0xca5e
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x5eac
movl (%rdx), %r10d
cmpl $0xfe, %r10d
jg 0x5eac
leaq 0x62aa(%rip), %rdi      # 0xc0c0
leaq 0x1(%rcx), %r11
movslq %r10d, %r8
cmpb $0x5c, %r9b
jne 0x5e43
movb (%r11), %r9b
movzbl %r9b, %r10d
leal -0x61(%r10), %r11d
cmpl $0x13, %r11d
ja 0x5e52
movslq (%rdi,%r11,4), %r10
addq %rdi, %r10
jmpq *%r10
movb $0x7, %r9b
jmp 0x5e7e
leal 0x1(%r8), %ecx
movl %ecx, (%rdx)
movb %r9b, (%rsi,%r8)
movq %r11, %rcx
jmp 0x5e88
cmpl $0x30, %r10d
jne 0x5e7e
xorl %r9d, %r9d
jmp 0x5e7e
movb $0x9, %r9b
jmp 0x5e7e
movb $0x1c, %r9b
jmp 0x5e7e
movb $0x1b, %r9b
jmp 0x5e7e
movb $0x1d, %r9b
jmp 0x5e7e
movb $0xa, %r9b
jmp 0x5e7e
movb $0xc, %r9b
jmp 0x5e7e
movb $0xd, %r9b
movb %r9b, (%rsi,%r8)
incl (%rdx)
addq $0x2, %rcx
movb (%rcx), %r9b
cmpb %al, %r9b
sete %r8b
testb %r9b, %r9b
je 0x5eac
cmpb %al, %r9b
je 0x5eac
movl (%rdx), %r10d
cmpl $0xfe, %r10d
jle 0x5e16
movzbl %r8b, %edi
leaq (%rcx,%rdi), %rax
cmpb $0x5e, (%rcx,%rdi)
jne 0x5ec5
movslq (%rdx), %rcx
orb $-0x80, -0x1(%rsi,%rcx)
incq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x62ed
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x62de
movq %rbx, %rdi
callq 0x2110
cmpq $0x7, %rax
jb 0x6425
cmpb $0x22, (%rbx)
jne 0x6425
cmpb $0x22, 0x6(%rbx)
jne 0x6425
xorl %ebp, %ebp
movl $0x5, %eax
movl $0x40, %ecx
decl %eax
movzbl (%rbx,%rax), %edx
cmpb $0x20, %dl
cmovel %ecx, %edx
movl $0x5b, %esi
cmpb $0x32, %dl
je 0x6336
movl %edx, %esi
movl $0x5c, %edx
cmpb $0x33, %sil
je 0x6343
movl %esi, %edx
leal -0x5d(%rdx), %esi
cmpb $-0x1f, %sil
jbe 0x6405
movl %ebp, %esi
movzbl %dl, %ebp
shll $0x5, %esi
addl $-0x3f, %ebp
orl %esi, %ebp
cmpl $0x1, %eax
ja 0x631e
movzbl 0x5(%rbx), %eax
cmpl $0x51, %eax
jg 0x637d
cmpl $0x43, %eax
je 0x638f
cmpl $0x44, %eax
jne 0x639d
orl $0x200000, %ebp         # imm = 0x200000
jmp 0x639d
cmpl $0x52, %eax
je 0x6397
cmpl $0x57, %eax
jne 0x639d
orl $0x400000, %ebp         # imm = 0x400000
jmp 0x639d
orl $0x100000, %ebp         # imm = 0x100000
jmp 0x639d
orl $0x300000, %ebp         # imm = 0x300000
cmpl $0x0, 0x1f674(%rip)     # 0x25a18
jne 0x63f0
cmpl $0x0, 0xbe0b(%rip)      # 0x121b8
je 0x63cd
movq 0x1f652(%rip), %rdi     # 0x25a08
leaq 0x6775(%rip), %rsi      # 0xcb32
leaq 0x1eadc(%rip), %rcx     # 0x24ea0
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movslq 0xe360(%rip), %rcx      # 0x14734
leaq 0xe875(%rip), %rax      # 0x14c50
addq %rcx, %rax
movl $0x3, %ecx
movb %bpl, -0x1(%rax,%rcx)
sarl $0x8, %ebp
decq %rcx
jne 0x63e3
addl $0x3, 0xe33d(%rip)      # 0x14734
addq $0x7, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x6713(%rip), %rdi      # 0xcb1f
xorl %eax, %eax
callq 0x2e63
movq %rbx, %rdi
callq 0x2dcf
movl $0x1, %edi
callq 0x22f0
leaq 0x66da(%rip), %rdi      # 0xcb06
jmp 0x640c
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x6451
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6442
leaq 0x7ed18(%rip), %rsi     # 0x85170
movq %rbx, %rdi
movl $0x4d, %edx
callq 0x380d
leaq 0x1e934(%rip), %rdi     # 0x24da0
leaq 0x7eaed(%rip), %rsi     # 0x84f60
callq 0x2090
cmpl $0x0, 0x1f599(%rip)     # 0x25a18
jne 0x64a6
cmpl $0x0, 0xbd30(%rip)      # 0x121b8
je 0x64a6
movq 0x1f577(%rip), %rdi     # 0x25a08
leaq 0x5dff(%rip), %rsi      # 0xc297
leaq 0x1ea01(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x1f562(%rip)     # 0x25a18
jne 0x64d1
cmpl $0x0, 0xbcf9(%rip)      # 0x121b8
je 0x64d1
callq 0x3005
movq %rbx, %rdi
callq 0x526e
movq %rax, %rbx
movb $0x0, 0x1e8c8(%rip)     # 0x24da0
movl $0x0, 0x7ec8e(%rip)     # 0x85170
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x6674
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6665
xorl %eax, %eax
cmpb $0x2a, (%rbx)
sete %al
leaq (%rbx,%rax), %rdi
movb (%rbx,%rax), %bpl
xorl %eax, %eax
movl $0x12, %ecx
cmpb $0x26, %bpl
sete %al
jne 0x669a
movl 0x7ee1e(%rip), %ecx     # 0x854b8
addq %rax, %rdi
leaq 0x4(%rsp), %rdx
movl %ecx, (%rdx)
movq %rsp, %r14
movq %r14, %rsi
callq 0x4b9d
movq %rax, %rbx
movl (%r14), %esi
cmpb $0x26, %bpl
jne 0x6730
movl 0x1f36f(%rip), %ecx     # 0x25a30
movl %ecx, %eax
cltd
idivl %esi
movl %esi, %eax
subl %edx, %eax
cltd
idivl %esi
movl %edx, (%rsp)
movq 0x1f339(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x66f7
movl %edx, %eax
addl %ecx, %eax
movl 0x4(%rsp), %r8d
leaq 0x6457(%rip), %rsi      # 0xcb43
movl %ecx, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x2210
movl (%rsp), %r14d
movl %r14d, %eax
subl $0x1, %eax
jb 0x67a4
movslq 0x1f322(%rip), %r15     # 0x25a30
movl 0x4(%rsp), %esi
leaq 0xe537(%rip), %rdi      # 0x14c50
addq %r15, %rdi
movq %r14, %rdx
callq 0x2180
leal (%r15,%r14), %eax
movl %eax, 0x1f302(%rip)     # 0x25a30
jmp 0x679f
movl 0xdffe(%rip), %ecx      # 0x14734
movl %ecx, %eax
cltd
idivl %esi
movl %esi, %eax
subl %edx, %eax
cltd
idivl %esi
movl %edx, (%rsp)
movq 0x1f2c4(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x676c
movl %edx, %eax
addl %ecx, %eax
movl 0x4(%rsp), %r8d
leaq 0x6407(%rip), %rsi      # 0xcb68
movl %ecx, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x2210
movl (%rsp), %r14d
movl %r14d, %eax
subl $0x1, %eax
jb 0x67a4
movslq 0xdfb5(%rip), %r15      # 0x14734
movl 0x4(%rsp), %esi
leaq 0xe4c6(%rip), %rdi      # 0x14c50
addq %r15, %rdi
movq %r14, %rdx
callq 0x2180
leal (%r15,%r14), %eax
movl %eax, 0xdf95(%rip)      # 0x14734
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rsp)
callq 0x3194
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl $0x3d, %esi
callq 0x3342
testq %rax, %rax
je 0x6803
incq %rax
leaq 0xdf46(%rip), %rsi      # 0x14734
movq %rax, %rdi
callq 0x34ef
movq %rax, %rbx
callq 0x3194
movq %rbx, %rax
popq %rbx
retq
incl 0x1f223(%rip)           # 0x25a2c
leaq 0x637d(%rip), %rdi      # 0xcb8d
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x34ef
movl (%r14), %ebp
testl %ebp, %ebp
js 0x685f
movq %rax, %rbx
callq 0x3194
addl %ebp, 0xdee9(%rip)      # 0x14734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6353(%rip), %rdi      # 0xcbb9
movl %ebp, %esi
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x638e(%rip), %rsi      # 0xcc12
callq 0x2969
testq %rax, %rax
je 0x68a3
addq $0x4, %rax
leaq 0xde9b(%rip), %rsi      # 0x14734
movq %rax, %rdi
xorl %edx, %edx
callq 0x3daa
callq 0x3194
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7ec07(%rip), %rsi     # 0x854bc
callq 0x34ef
movq %rax, %rbx
movl 0x7ebf9(%rip), %eax     # 0x854bc
cmpl $0x100, %eax            # imm = 0x100
jl 0x68d3
shrl $0x8, %eax
movl %eax, 0x7ebe9(%rip)     # 0x854bc
movl 0x7ebe3(%rip), %edi     # 0x854bc
callq 0x31ca
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x690d
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x68fe
movl $0x8, %r15d
leaq 0xe0f6(%rip), %r12      # 0x14a10
movq -0x8(%r15,%r12), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2cc9
testl %eax, %eax
je 0x693d
addq $0x10, %r15
cmpq $0x228, %r15            # imm = 0x228
jne 0x691a
jmp 0x6960
movq (%r15,%r12), %r15
movq %r14, %rdi
callq 0x2110
addq %rax, %rbx
movq %rbx, %rdi
callq *%r15
cmpl $0x10001, 0xddd8(%rip)  # imm = 0x10001
jge 0x696f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x6352(%rip), %rdi      # 0xcccb
xorl %eax, %eax
callq 0x2e63
movq %rbx, %rdi
callq 0x2dcf
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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
leaq (%rax,%rax,4), %rax
leaq 0xb395(%rip), %rcx      # 0x121c0
leaq (%rcx,%rax,8), %rbx
leaq 0x5fd9(%rip), %rsi      # 0xce0f
movq %rbx, %rdi
movl $0x4, %edx
callq 0x2c50
movl $0x1, %ebp
testl %eax, %eax
je 0x6e8f
leaq 0x5fc1(%rip), %rsi      # 0xce14
movq %rbx, %rdi
movl $0x4, %edx
callq 0x2c50
testl %eax, %eax
je 0x6e8f
movq %rbx, %rdi
callq 0x2110
movsbl -0x1(%rax,%rbx), %esi
leal -0x41(%rsi), %eax
cmpb $0x19, %al
jae 0x6e98
movzbl %al, %eax
movl $0x1d5003f, %ecx        # imm = 0x1D5003F
btl %eax, %ecx
jae 0x6e98
leaq 0x52e8(%rip), %rcx      # 0xc174
movl (%rcx,%rax,4), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5f7a(%rip), %rdi      # 0xce19
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xf, %r12d
movq 0xd7f4(%rip), %r13      # 0x146c0
movq (%r13,%r12,8), %r15
movq %r15, %rdi
callq 0x2110
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x2c50
testl %eax, %eax
je 0x6ef6
addq $-0x1, %r12
jb 0x6ecc
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %r12d, %r12d
js 0x6f51
movl %r12d, (%r14)
movq 0xd7bb(%rip), %rax      # 0x146c0
movl %r12d, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2110
movq %rax, %r14
cmpb $0x0, (%rbx,%rax)
je 0x6f39
callq 0x2320
movq (%rax), %rax
addq %r14, %rbx
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6f28
jmp 0x6f3c
addq %r14, %rbx
xorl %eax, %eax
cmpb $0x2c, (%rbx)
sete %al
addq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2dcf
leaq 0x5ed5(%rip), %rdi      # 0xce35
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0xd73d(%rip), %r15      # 0x146c0
callq 0x2030
movq (%rax), %rax
movsbq (%rbx), %rcx
movl (%rax,%rcx,4), %ecx
movl $0x4, %eax
movl %eax, %edx
movq (%r15,%rdx,8), %rdx
movsbl (%rdx), %edx
cmpl %edx, %ecx
je 0x6fae
addl $-0x1, %eax
jb 0x6f97
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x6fc1
movl %eax, (%r14)
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2dcf
leaq 0x5e8d(%rip), %rdi      # 0xce5d
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x1ea44(%rip)           # 0x25a2c
callq 0x2dcf
leaq 0x5e99(%rip), %rdi      # 0xce8d
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x7029
addl $-0x73, %eax
cmpl $0x6, %eax
ja 0x7056
leaq 0x510c(%rip), %rcx      # 0xc12c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x50e0(%rip), %rax      # 0xc110
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x60, %eax
jmp 0x7050
xorl %eax, %eax
jmp 0x7050
movl $0x20, %eax
jmp 0x7050
movl $0x40, %eax
testl %edi, %edi
jns 0x7056
popq %rcx
retq
movq %rsi, %rdi
callq 0x6fe1