LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/main.c
// Function: main
int main(void){
  int result=printf("mcd(32,132)=%d\n",mcd(32,132));
  printf("mcd(8,64)=%d\n",mcd(8,64));
  printf("mcd(65,2048)=%d\n",mcd(65,2048));

  int m=mcd(32,132);
  int arr[]={32,132};
  simplificar(arr);
  printf("32/132=%d/%d\n",arr[0],arr[1]);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x20
popq %r14
movl %r14d, %edi
movl $0x84, %esi
callq 0x1270
leaq 0xe2d(%rip), %rdi       # 0x2014
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl %eax, %ebx
pushq $0x8
popq %rdi
pushq $0x40
popq %rsi
callq 0x1270
leaq 0xe20(%rip), %rdi       # 0x2024
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
pushq $0x41
popq %rdi
movl $0x800, %esi            # imm = 0x800
callq 0x1270
leaq 0xe11(%rip), %rdi       # 0x2032
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl %r14d, %edi
movl $0x84, %esi
callq 0x1270
movabsq $0x8400000020, %rax     # imm = 0x8400000020
leaq -0x18(%rbp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x113c
movl (%r14), %esi
movl 0x4(%r14), %edx
leaq 0xde5(%rip), %rdi       # 0x2043
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/otro.c
// Function: mcd
int mcd(int n,int d)
{
  int N,D,R;
  N=abs(n);
  D=abs(d);
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
fin:
  return N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
negl %ebx
cmovsl %edi, %ebx
movl %esi, %ecx
negl %ecx
cmovsl %esi, %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %ebx
testl %edx, %edx
je 0x132a
movl %edx, %r14d
leaq 0xd64(%rip), %rdi       # 0x2004
movl %ecx, %esi
movl %eax, %edx
movl %ebx, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
testl %edx, %edx
je 0x1322
movl %edx, %r15d
leaq 0xd3f(%rip), %rdi       # 0x2004
movl %ebx, %esi
movl %eax, %edx
movl %r14d, %ecx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x1030
movl %r14d, %eax
xorl %edx, %edx
divl %r15d
testl %edx, %edx
je 0x1327
movl %edx, %ebx
leaq 0xd19(%rip), %rdi       # 0x2004
movl %r14d, %esi
movl %eax, %edx
movl %r15d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1030
movl %r15d, %eax
xorl %edx, %edx
divl %ebx
testl %edx, %edx
je 0x132a
movl %edx, %r8d
leaq 0xcf2(%rip), %rdi       # 0x2004
movl %r15d, %esi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1030
jmp 0x132a
movl %r14d, %ebx
jmp 0x132a
movl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: StrCaseStr
char *StrCaseStr(char *s1, const char *s2)
{
   char h1[MAX_STR];
   char h2[MAX_STR];
   char *r;
   unsigned int i;

   memset(h1,0,sizeof(h1));
   memset(h2,0,sizeof(h2));

    for (i=0 ; i < strlen(s1) && i < sizeof(h1)-1 ; ++i)
        h1[i] = toupper(s1[i]);
    for (i=0 ; i < strlen(s2) && i < sizeof(h2)-1 ; ++i)
        h2[i] = toupper(s2[i]);

    r = strstr(h1,h2);
    if (r) r = s1 + (r - h1);
    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x400(%rsp), %r14
xorl %r12d, %r12d
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x2180
movq %rsp, %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x2180
movq %rbx, %rdi
callq 0x2110
movl $0x3ff, %r13d           # imm = 0x3FF
cmpq %r13, %rax
cmovbq %rax, %r13
cmpq %r13, %r12
jae 0x24c4
callq 0x2030
movq (%rax), %rax
movsbq (%rbx,%r12), %rcx
movb (%rax,%rcx,4), %al
movb %al, 0x400(%rsp,%r12)
incq %r12
jmp 0x24a2
movq %r15, %rdi
callq 0x2110
movl $0x3ff, %r12d           # imm = 0x3FF
cmpq %r12, %rax
cmovbq %rax, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x24fa
callq 0x2030
movq (%rax), %rax
movsbq (%r15,%r13), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rsp,%r13)
incq %r13
jmp 0x24dc
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2310
movq %rax, %rcx
subq %r14, %rcx
addq %rcx, %rbx
testq %rax, %rax
cmovneq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: StrNDup
char *StrNDup(void *src, unsigned int n)
{
   char *dst;
   if (n > MAX_STR)
   {
      fprintf(stderr,"*** tried to allocate %d bytes for string\n",n);
      fprintf(stderr,"*** current maximum length is %d\n",MAX_STR);
      exit(1);
   }
   dst = (char *)MallocOrDie(n+1);
   memmove(dst,src,n);
   return dst;
 }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $0x401, %esi            # imm = 0x401
jae 0x25bc
movq %rdi, %r14
leal 0x1(%rbx), %edi
callq 0x2554
movl %ebx, %edx
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22a0
movq 0xea35(%rip), %r14      # 0x10ff8
movq (%r14), %rdi
leaq 0x8ba5(%rip), %rsi      # 0xb172
movl %ebx, %edx
xorl %eax, %eax
callq 0x2210
movq (%r14), %rdi
leaq 0x8bbd(%rip), %rsi      # 0xb19d
movl $0x400, %edx            # imm = 0x400
xorl %eax, %eax
callq 0x2210
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: MneStat
void MneStat(void)
{
   unsigned int i,j;

   for (i=0 ; i < DIMOP_6309 ; ++i)
   for (j=0 ; j < strlen(Mat[i].Mne) ; ++j)
      ++Cstat[Mat[i].Mne[j]-'A'];

   for (i=0 ; i < 26 ; ++i)
      printf("%c:%3d\n",'A'+i,Cstat[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r15d, %r15d
leaq 0xebba(%rip), %r12      # 0x111c0
leaq 0x21773(%rip), %r14     # 0x23d80
cmpq $0xe6, %r15
je 0x2641
imulq $0x28, %r15, %rbx
addq %r12, %rbx
movq %rbx, %rdi
callq 0x2110
xorl %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x263c
movsbq (%rbx,%rcx), %rdx
incb -0x41(%rdx,%r14)
incl %ecx
jmp 0x2627
incq %r15
jmp 0x260d
leaq 0x8b7d(%rip), %rbx      # 0xb1c5
xorl %r15d, %r15d
cmpq $0x1a, %r15
je 0x2669
movsbl (%r15,%r14), %edx
leal 0x41(%r15), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2130
incq %r15
jmp 0x264b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: StrMatch
char *StrMatch(char *s, const char *m)
{
   int i,j,k,l;

   k = strlen(s);
   l = strlen(m);

   for (j = 0 ; j <= k-l ; ++j)
   {
      if (s[j] == ';') break;  // don't search comment
      for (i = 0 ; i < l ; ++i)
      {
         if (toupper(s[j+i]) != toupper(m[i])) break;
      }
      if (i == l) return (s + j);
   }
   return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x2110
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
movq %rax, %r12
subl %r12d, %ebx
testl %r12d, %r12d
movl $0x0, %r13d
cmovgl %r12d, %r13d
movslq %ebx, %rax
movq %rax, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %r15, %rbx
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
jg 0x273b
movq %rax, %r15
movq 0x8(%rsp), %rax
cmpb $0x3b, (%rax,%r15)
je 0x273b
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x2722
callq 0x2030
movq (%rax), %rax
movsbq (%rbx,%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movsbq (%r14,%rbp), %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0x2725
incq %rbp
jmp 0x26fe
movl %r13d, %ebp
leaq 0x1(%r15), %rax
incq %rbx
cmpl %r12d, %ebp
jne 0x26e6
movq 0x8(%rsp), %rax
addq %r15, %rax
jmp 0x273d
xorl %eax, %eax
addq $0x18, %rsp
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: StrKey
char *StrKey(char *s, const char *m)
{
   char *r = StrMatch(s,m);
   if (r) // match was true
   {
      if ((r > s && isalnum(*(r-1))) ||       // check before
         (isalnum(*(r+strlen(m))))) r = NULL; // check after
   }
   return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x269d
testq %rax, %rax
je 0x2793
movq %rax, %rbx
callq 0x2320
cmpq %r15, %rbx
jbe 0x277c
movq (%rax), %rcx
movsbq -0x1(%rbx), %rdx
testb $0x8, (%rcx,%rdx,2)
jne 0x2793
movq (%rax), %r15
movq %r14, %rdi
callq 0x2110
movsbq (%rbx,%rax), %rax
testb $0x8, (%r15,%rax,2)
je 0x2795
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: GetSymbol
char *GetSymbol(char *p, char *s)
{
   if (*p == '.') // expand local symbol
   {
      if (Scope[0])
      {
         strcpy(s,Scope);
         s += strlen(s);
         *s++ = *p++;
      }
   }
   if (*p == '_' || isalpha(*p)) while (isym(*p)) *s++ = *p++;
   *s = 0;
   return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %bpl
cmpb $0x2e, %bpl
jne 0x281c
cmpb $0x0, 0x215b0(%rip)     # 0x23da0
je 0x281c
leaq 0x215a7(%rip), %rsi     # 0x23da0
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2110
movb (%r14), %cl
addq %rax, %rbx
incq %rbx
movb %cl, -0x1(%rbx)
movb 0x1(%r14), %bpl
incq %r14
cmpb $0x5f, %bpl
je 0x2844
callq 0x2320
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0x2844
jmp 0x2851
movb %bpl, (%rbx)
incq %rbx
movb 0x1(%r14), %bpl
incq %r14
movsbl %bpl, %edi
callq 0x279e
testl %eax, %eax
jne 0x2837
movb $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: GetMacroArg
char *GetMacroArg(char *p, char *s)
{
   p = SkipSpace(p);
   while (*p && *p != ',' && *p != ')') *s++ = *p++;
   *s = 0;
   return p;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x2675
movabsq $0x120000000001, %rcx   # imm = 0x120000000001
movzbl (%rax), %edx
cmpq $0x2c, %rdx
ja 0x287e
btq %rdx, %rcx
jb 0x2888
incq %rax
movb %dl, (%rbx)
incq %rbx
jmp 0x286f
movb $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: StrCaseCmp
int StrCaseCmp(const char *a, const char *b)
{
   unsigned int i,l,m;

   l = strlen(a);
   m = strlen(b);

   for (i=0 ; i <= l && i <= m ; ++i)
   {
      if (toupper(a[i]) < toupper(b[i])) return -1;
      if (toupper(a[i]) > toupper(b[i])) return  1;
   }
   return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2110
movq %rax, %r12
movq %rbx, %rdi
callq 0x2110
movq %rax, %r15
cmpl %r15d, %r12d
cmovbl %r12d, %r15d
xorl %ebp, %ebp
pushq $0x1
popq %r13
xorl %r12d, %r12d
cmpl %r15d, %r12d
ja 0x2909
callq 0x2030
movq (%rax), %rcx
movl %r12d, %edx
movsbq (%r14,%rdx), %rax
movl (%rcx,%rax,4), %eax
movsbq (%rbx,%rdx), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jl 0x2906
incl %r12d
cmpl %ecx, %eax
jle 0x28d6
movl %r13d, %ebp
jmp 0x2909
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
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: strcmpword
int strcmpword(const char *s1, const char *s2)
{
   int l = strlen(s2);
   int r = StrNCaseCmp(s1,s2,l);
   if (r == 0 && isym(s1[l])) r = 1;
   return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2110
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x291a
testl %eax, %eax
je 0x29c2
popq %rbx
popq %r14
popq %r15
retq
movslq %r14d, %rax
movsbl (%rbx,%rax), %edi
popq %rbx
popq %r14
popq %r15
jmp 0x279e
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: SkipHexCode
char *SkipHexCode(char *p)
{
   int l;

   l = strlen(p);
   if (l > 20 && isdigit(p[4]) && isspace(p[5]) &&
       isxdigit(p[6]) && isxdigit(p[7]) &&
       isxdigit(p[8]) && isxdigit(p[9]) &&
       p[0] != ';')
   {
      if (SkipHex) memmove(Line,Line+20,l-19);
      else return (p+20);
   }
   return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
cmpl $0x15, %r14d
jl 0x2a66
callq 0x2320
movq (%rax), %rax
movsbq 0x4(%rbx), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x2a66
movsbq 0x5(%rbx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x2a66
movsbq 0x6(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2a66
movsbq 0x7(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2a66
movsbq 0x8(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2a66
movsbq 0x9(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2a66
cmpb $0x3b, (%rbx)
je 0x2a66
cmpl $0x0, 0x2130c(%rip)     # 0x23d50
je 0x2a62
addl $-0x13, %r14d
leaq 0x2144f(%rip), %rdi     # 0x23ea0
leaq 0x2145c(%rip), %rsi     # 0x23eb4
movq %r14, %rdx
callq 0x22a0
jmp 0x2a66
addq $0x14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ErrorLine
void ErrorLine(char *p)
{
   int i,ep;
   printf("%s\n",Line);
   ep = p - Line;
   if (ep >= 0 && ep < 80)
   {
      for (i=0 ; i < ep ; ++i) printf(" ");
      printf("^\n");
      return;
   }
   ep = p - OpText;
   if (ep >= 0 && ep < 80 && *OpText)
   {
      printf("Operand: %s\n",OpText);
      for (i=0 ; i < ep+9 ; ++i) printf(" ");
      printf("^\n");
      return;
   }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x21421(%rip), %r14     # 0x23ea0
movq %r14, %rdi
callq 0x20a0
movl %ebx, %ebp
subl %r14d, %ebp
cmpl $0x4f, %ebp
ja 0x2aa2
pushq $0x20
popq %rbx
subl $0x1, %ebp
jb 0x2ae2
movl %ebx, %edi
callq 0x2050
jmp 0x2a94
leaq 0x214f7(%rip), %rax     # 0x23fa0
subl %eax, %ebx
cmpl $0x4f, %ebx
ja 0x2af2
cmpb $0x0, 0x214e9(%rip)     # 0x23fa0
je 0x2af2
leaq 0x870d(%rip), %rdi      # 0xb1cd
leaq 0x214d9(%rip), %rsi     # 0x23fa0
xorl %eax, %eax
callq 0x2130
addl $0x9, %ebx
pushq $0x20
popq %rbp
subl $0x1, %ebx
jb 0x2ae2
movl %ebp, %edi
callq 0x2050
jmp 0x2ad4
leaq 0x9eec(%rip), %rdi      # 0xc9d5
popq %rbx
popq %r14
popq %rbp
jmp 0x20a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ErrorMsg
void ErrorMsg(const char *format, ...) {
   va_list args;
   char *buf;

   buf = (char *)MallocOrDie(SIZE_ERRMSG);
   snprintf(buf, SIZE_ERRMSG, "\n*** Error in file %s line %d:\n",
         IncludeStack[IncludeLevel].Src, LiNo);
   va_start(args,format);
   vsnprintf(buf+strlen(buf), SIZE_ERRMSG-strlen(buf), format, args);
   va_end(args);
   fputs(Line, stdout);
   fputs(Line, lf);
   fputs(buf, stdout);
   fputs(buf, lf);
   if (df)
   {
      fputs(Line, df);
      fputs(buf, df);
      // ListSymbols(df,Labels,0,0xffff);
   }
   free(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %r13
movq %rsi, 0x8(%r13)
movq %rdx, 0x10(%r13)
movq %rcx, 0x18(%r13)
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
testb %al, %al
je 0x2b5e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl $0x400, %r15d           # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x2554
movq %rax, %rbx
movslq 0x21e88(%rip), %rax     # 0x24a00
imulq $0x18, %rax, %rax
leaq 0x2151d(%rip), %rcx     # 0x240a0
movq 0x10(%rax,%rcx), %rcx
movl 0x211c9(%rip), %r8d     # 0x23d58
leaq 0x8644(%rip), %rdx      # 0xb1da
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2150
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r12)
movq %r13, 0x10(%r12)
movq %rbx, %rdi
callq 0x2110
leaq (%rbx,%rax), %rdi
subq %rax, %r15
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x20f0
movq 0xe3ec(%rip), %r15      # 0x10fd8
movq (%r15), %rsi
leaq 0x212aa(%rip), %r14     # 0x23ea0
movq %r14, %rdi
callq 0x2170
movq 0x21e03(%rip), %rsi     # 0x24a08
movq %r14, %rdi
callq 0x2170
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2170
movq 0x21de9(%rip), %rsi     # 0x24a08
movq %rbx, %rdi
callq 0x2170
movq 0x21de2(%rip), %rsi     # 0x24a10
testq %rsi, %rsi
je 0x2c4e
leaq 0x21266(%rip), %rdi     # 0x23ea0
callq 0x2170
movq 0x21dca(%rip), %rsi     # 0x24a10
movq %rbx, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2040
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: PrintOC
void PrintOC(int v)
{

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

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

   // opcode value is 16 or 8 bit

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

   // postbyte

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

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

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

// Assembly:
pushq %rbx
cmpl $0x0, 0xe4f8(%rip)      # 0x111b8
je 0x2cf0
movl %edi, %ebx
movl 0x21d52(%rip), %edx     # 0x24a1c
cmpl $0xcd, %edx
jne 0x2cf2
movq 0x21d2f(%rip), %rdi     # 0x24a08
movl %ebx, %edx
shrl $0x10, %edx
movzwl %bx, %ecx
leaq 0x8517(%rip), %rsi      # 0xb1ff
xorl %eax, %eax
popq %rbx
jmp 0x2210
popq %rbx
retq
cmpl $0x100, %edx            # imm = 0x100
movq 0x21d09(%rip), %rdi     # 0x24a08
leaq 0x984e(%rip), %rax      # 0xc554
leaq 0x851c(%rip), %rsi      # 0xb229
cmovgeq %rax, %rsi
xorl %eax, %eax
callq 0x2210
movl 0x21d02(%rip), %edx     # 0x24a20
movq 0x21ce3(%rip), %rcx     # 0x24a08
testl %edx, %edx
js 0x2d3c
leaq 0x84fb(%rip), %rsi      # 0xb22b
movq %rcx, %rdi
xorl %eax, %eax
callq 0x2210
jmp 0x2d4e
leaq 0x9901(%rip), %rdi      # 0xc644
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
movl 0x21cd0(%rip), %eax     # 0x24a24
movq 0x21cad(%rip), %rcx     # 0x24a08
cmpl $0x1, %eax
je 0x2d71
cmpl $0x2, %eax
jne 0x2d86
movzwl %bx, %edx
leaq 0x97e5(%rip), %rsi      # 0xc554
jmp 0x2d7b
movzbl %bl, %edx
leaq 0x84ae(%rip), %rsi      # 0xb229
movq %rcx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x2210
leaq 0x98b5(%rip), %rdi      # 0xc642
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
jmp 0x2300
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: PrintByteLine
void PrintByteLine(int b)
{
   if (!ListOn || Pass) return;
   PrintLiNo();
   fprintf(lf,"       %2.2x",b);
   fprintf(lf,"         %s\n",Line);
}

// Assembly:
cmpl $0x0, 0xe3ac(%rip)      # 0x111b8
je 0x2e53
cmpl $0x0, 0x21c03(%rip)     # 0x24a18
jne 0x2e53
pushq %rbx
movl %edi, %ebx
callq 0x2c67
movq 0x21be2(%rip), %rdi     # 0x24a08
leaq 0x83f8(%rip), %rsi      # 0xb225
movl %ebx, %edx
xorl %eax, %eax
callq 0x2210
movq 0x21bcb(%rip), %rdi     # 0x24a08
leaq 0x83d4(%rip), %rsi      # 0xb218
leaq 0x21055(%rip), %rdx     # 0x23ea0
xorl %eax, %eax
popq %rbx
jmp 0x2210
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: PrintWordLine
void PrintWordLine(int w)
{
   if (!ListOn || Pass) return;
   PrintLiNo();
   fprintf(lf,"%4.4x",w);
   fprintf(lf,"              %s\n",Line);
}

// Assembly:
cmpl $0x0, 0xe35d(%rip)      # 0x111b8
je 0x2ea2
cmpl $0x0, 0x21bb4(%rip)     # 0x24a18
jne 0x2ea2
pushq %rbx
movl %edi, %ebx
callq 0x2c67
movq 0x21b93(%rip), %rdi     # 0x24a08
leaq 0x96d9(%rip), %rsi      # 0xc555
movl %ebx, %edx
xorl %eax, %eax
callq 0x2210
movq 0x21b7c(%rip), %rdi     # 0x24a08
leaq 0x8380(%rip), %rsi      # 0xb213
leaq 0x21006(%rip), %rdx     # 0x23ea0
xorl %eax, %eax
popq %rbx
jmp 0x2210
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: IsInstruction
int IsInstruction(char *p)
{
   int i,l;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq 0x106f8(%rip), %rbp     # 0x135b0
leaq 0xe301(%rip), %r15      # 0x111c0
xorl %r13d, %r13d
pushq $-0x1
popq %rbx
cmpq %rbp, %r13
jge 0x2f04
movq %r15, %rdi
callq 0x2110
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x291a
testl %eax, %eax
jne 0x2ef8
movslq %r12d, %rax
movsbl (%r14,%rax), %edi
callq 0x279e
testl %eax, %eax
je 0x2f01
incq %r13
addq $0x28, %r15
jmp 0x2ec5
movl %r13d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
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: ParseCaseData
char *ParseCaseData(char *p)
{
   p = SkipSpace(p);
        if (*p == '+') IgnoreCase = 0;
   else if (*p == '-') IgnoreCase = 1;
   else
   {
      ++ErrNum;
      ErrorMsg("Missing '+' or '-' after CASE\n");
      exit(1);
   }
   PrintLine();
   return p+1;
}

// Assembly:
pushq %rbx
callq 0x2675
movq %rax, %rbx
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2b, %ecx
je 0x2f42
cmpl $0x2d, %ecx
jne 0x2f55
pushq $0x1
popq %rax
movl %eax, 0x21ae0(%rip)     # 0x24a28
callq 0x2d99
incq %rbx
movq %rbx, %rax
popq %rbx
retq
incl 0x21ad1(%rip)           # 0x24a2c
leaq 0x82d0(%rip), %rdi      # 0xb232
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ParseListOption
char *ParseListOption(char *p)
{
   p = SkipSpace(p);
        if (*p == '+') ListGlobal = 1;
   else if (*p == '-') ListGlobal = 0;
   else
   {
      ++ErrNum;
      ErrorMsg("Missing '+' or '-' after LIST\n");
      exit(1);
   }
   ListOn = ListGlobal;
   PrintLine();
   return p+1;
}

// Assembly:
pushq %rbx
callq 0x2675
movq %rax, %rbx
movzbl (%rax), %eax
cmpl $0x2b, %eax
je 0x2f8b
cmpl $0x2d, %eax
jne 0x2fa7
xorl %eax, %eax
jmp 0x2f8e
pushq $0x1
popq %rax
movl %eax, 0xe220(%rip)      # 0x111b4
movl %eax, 0xe21e(%rip)      # 0x111b8
callq 0x2d99
incq %rbx
movq %rbx, %rax
popq %rbx
retq
incl 0x21a7f(%rip)           # 0x24a2c
leaq 0x829d(%rip), %rdi      # 0xb251
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: SetBSS
char *SetBSS(char *p)
{
   p = NeedChar(p,'=');
   if (!p)
   {
      ++ErrNum;
      ErrorMsg("Missing '=' in set BSS & instruction\n");
      exit(1);
   }
   p = ExtractValue(p+1,&bss);
   if (ListOn && !Pass)
   {
      PrintLiNo();
      fprintf(lf,"%4.4x              %s\n",bss,Line);
   }
   return p;
}

// Assembly:
pushq %rbx
pushq $0x3d
popq %rsi
callq 0x2f15
testq %rax, %rax
je 0x3024
incq %rax
leaq 0x21a55(%rip), %rsi     # 0x24a30
movq %rax, %rdi
callq 0x3040
movq %rax, %rbx
cmpl $0x0, 0xe1cb(%rip)      # 0x111b8
je 0x301f
cmpl $0x0, 0x21a22(%rip)     # 0x24a18
jne 0x301f
callq 0x2c67
movq 0x21a04(%rip), %rdi     # 0x24a08
movl 0x21a26(%rip), %edx     # 0x24a30
leaq 0x8285(%rip), %rsi      # 0xb296
leaq 0x20e88(%rip), %rcx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
incl 0x21a02(%rip)           # 0x24a2c
leaq 0x823f(%rip), %rdi      # 0xb270
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ExtractValue
char *ExtractValue(char *p, int *v)
{
   char *r; // pointer to trailing text after value (should be none)

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x31b3
movq %rax, %rbx
cmpb $0x0, 0x20f4a(%rip)     # 0x23fa0
je 0x3079
leaq 0x20f41(%rip), %rdi     # 0x23fa0
movq %r14, %rsi
xorl %edx, %edx
callq 0x37d5
cmpb $0x0, (%rax)
jne 0x308a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2a71
leaq 0x8514(%rip), %rdi      # 0xb59c
jmp 0x3099
movq %rax, %rdi
callq 0x2a71
leaq 0x8512(%rip), %rdi      # 0xb5ab
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: MacroIndex
int MacroIndex(char *p)
{
   int i,l;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq 0x7f4ea(%rip), %rbp     # 0x82640
leaq 0x7f4f3(%rip), %rbx     # 0x82650
xorl %r13d, %r13d
cmpq %rbp, %r13
jge 0x319c
movq (%rbx), %r12
movq %r12, %rdi
callq 0x2110
movslq %eax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x30ba
testl %eax, %eax
jne 0x3193
movsbl (%r14,%r15), %edi
callq 0x279e
testl %eax, %eax
je 0x31a1
incq %r13
addq $0x20, %rbx
jmp 0x3160
pushq $-0x1
popq %rax
jmp 0x31a4
movl %r13d, %eax
addq $0x8, %rsp
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: ExtractOpText
char *ExtractOpText(char *p)
{
   int l,inquo,inapo;

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

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

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

   // Extract operand

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, 0x80d8e(%rip)     # 0x83f50
movb $0x0, 0x20dd7(%rip)     # 0x23fa0
callq 0x2675
movq %rax, %rbx
movzbl (%rax), %eax
testl %eax, %eax
je 0x32bf
cmpl $0x3e, %eax
je 0x31e6
cmpl $0x3c, %eax
jne 0x31f2
addl $-0x3d, %eax
movl %eax, 0x80d61(%rip)     # 0x83f50
incq %rbx
cmpl $0x1, 0x80d5b(%rip)     # 0x83f54
jne 0x3224
xorl %r14d, %r14d
leaq 0x20d9b(%rip), %rax     # 0x23fa0
movb (%rbx,%r14), %cl
testb %cl, %cl
je 0x327d
cmpb $0x20, %cl
je 0x327d
cmpq $0xff, %r14
ja 0x327d
movb %cl, (%r14,%rax)
incq %r14
jmp 0x3205
xorl %r14d, %r14d
leaq 0x20d72(%rip), %r15     # 0x23fa0
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rbx,%r14), %dl
testb %dl, %dl
je 0x3282
cmpq $0x100, %r14            # imm = 0x100
jae 0x3282
xorl %esi, %esi
testl %eax, %eax
sete %sil
xorl %edi, %edi
testl %ecx, %ecx
cmovnel %eax, %esi
sete %dil
cmpb $0x22, %dl
cmovel %esi, %eax
testl %eax, %eax
cmovnel %ecx, %edi
cmpb $0x27, %dl
cmovel %edi, %ecx
cmpb $0x3b, %dl
jne 0x3274
testl %eax, %eax
jne 0x3274
testl %ecx, %ecx
je 0x3282
movb %dl, (%r14,%r15)
incq %r14
jmp 0x3232
addq %r14, %rbx
jmp 0x32b1
addq %r14, %rbx
movq %r14, %r12
subq $0x1, %r12
jb 0x32ae
callq 0x2320
movq (%rax), %rax
movsbq -0x1(%r14,%r15), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x32b1
movb $0x0, -0x1(%r14,%r15)
movq %r12, %r14
jmp 0x3288
xorl %r14d, %r14d
movslq %r14d, %rax
leaq 0x20ce5(%rip), %rcx     # 0x23fa0
movb $0x0, (%rax,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: SymRefs
void SymRefs(int i)
{
   int n;

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

// Assembly:
cmpl $0x0, 0x20f88(%rip)     # 0x24a18
je 0x3a93
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %rax
imulq $0x30, %rax, %r14
leaq 0x20f97(%rip), %r15     # 0x24a40
movslq 0x18(%r14,%r15), %r12
leaq 0x1(%r12), %rax
movl %eax, 0x18(%r14,%r15)
movq 0x20(%r14,%r15), %rdi
leaq 0x8(,%r12,4), %rbx
movq %rbx, %rsi
callq 0x2566
movq %rax, 0x20(%r14,%r15)
movl 0x20280(%rip), %ecx     # 0x23d58
movl %ecx, 0x4(%rax,%r12,4)
movq 0x28(%r14,%r15), %rdi
movq %rbx, %rsi
callq 0x2566
movq %rax, 0x28(%r14,%r15)
movl 0x8056f(%rip), %ecx     # 0x84064
movl %ecx, 0x4(%rax,%r12,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: EvalSymValue
char *EvalSymValue(char *p, int *v)
{
   int i;
   char Sym[ML];

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rsp, %r15
movq %r15, %rsi
callq 0x27d6
movq %rax, %rbx
movl 0x20f05(%rip), %r13d    # 0x24a34
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
leaq 0x20f00(%rip), %rbp     # 0x24a40
cmpq %r12, %r13
je 0x3b5e
movq (%rbp), %rsi
movq %r15, %rdi
callq 0x30a8
testl %eax, %eax
je 0x3b6f
incq %r12
addq $0x30, %rbp
jmp 0x3b40
movq %rsp, %rdi
callq 0x3b92
movl $0xff0000, (%r14)       # imm = 0xFF0000
jmp 0x3b7d
movl 0xc(%rbp), %eax
movl %eax, (%r14)
movl %r12d, %edi
callq 0x3a89
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_O2/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 0x20e92(%rip), %r15     # 0x24a34
cmpq $0x1f3f, %r15           # imm = 0x1F3F
jge 0x3cc7
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
movl 0xf9f0(%rip), %eax      # 0x135b0
xorl %r12d, %r12d
testl %eax, %eax
cmovgl %eax, %r12d
incq %r12
leaq 0xd5ed(%rip), %rsi      # 0x111c0
decq %r12
je 0x3bf4
leaq 0x28(%rsi), %r13
movq %rbx, %rdi
callq 0x28a2
movq %r13, %rsi
testl %eax, %eax
jne 0x3bd3
leaq 0x806f(%rip), %rdi      # 0xbc61
jmp 0x3c24
xorl %ecx, %ecx
leaq 0xfe13(%rip), %r12      # 0x13a10
leaq 0x10(%rcx), %r13
cmpq $0x230, %r13            # imm = 0x230
je 0x3c36
movq (%rcx,%r12), %rsi
movq %rbx, %rdi
callq 0x28a2
movq %r13, %rcx
testl %eax, %eax
jne 0x3bfd
leaq 0x8070(%rip), %rdi      # 0xbc94
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
imulq $0x30, %r15, %rax
leaq 0x20dff(%rip), %r15     # 0x24a40
movl $0xff0000, 0xc(%rax,%r15) # imm = 0xFF0000
movq %rbx, %rdi
movl %r14d, %esi
callq 0x258f
movslq 0x20dd8(%rip), %rcx     # 0x24a34
imulq $0x30, %rcx, %rcx
movq %rax, (%rcx,%r15)
pushq $0x4
popq %rbx
movq %rbx, %rdi
callq 0x2554
movslq 0x20dbe(%rip), %rcx     # 0x24a34
imulq $0x30, %rcx, %rcx
movq %rax, 0x20(%rcx,%r15)
movq %rbx, %rdi
callq 0x2554
movslq 0x20da6(%rip), %rcx     # 0x24a34
imulq $0x30, %rcx, %rcx
movq %rax, 0x28(%rcx,%r15)
movl 0x200bb(%rip), %eax     # 0x23d58
movq 0x20(%rcx,%r15), %rcx
movl %eax, (%rcx)
movslq 0x20d89(%rip), %rax     # 0x24a34
imulq $0x30, %rax, %rax
movq 0x28(%rax,%r15), %rax
andl $0x0, (%rax)
incl 0x20d77(%rip)           # 0x24a34
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
incl 0x20d5f(%rip)           # 0x24a2c
leaq 0x75d9(%rip), %rdi      # 0xb2ad
movl $0x1f40, %esi           # imm = 0x1F40
xorl %eax, %eax
callq 0x2af7
jmp 0x3c2e
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %r15, %rsi
callq 0x27d6
movq %rax, %rbx
movl 0x20d26(%rip), %r13d    # 0x24a34
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
leaq 0x20d31(%rip), %rbp     # 0x24a50
cmpq %r12, %r13
je 0x3d3d
movq -0x10(%rbp), %rsi
movq %r15, %rdi
callq 0x30a8
testl %eax, %eax
je 0x3d4e
incq %r12
addq $0x30, %rbp
jmp 0x3d1f
movq %rsp, %rdi
callq 0x3b92
movl $0xff0000, (%r14)       # imm = 0xFF0000
jmp 0x3d5c
movl (%rbp), %eax
movl %eax, (%r14)
movl %r12d, %edi
callq 0x3a89
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_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbl (%rdi), %edi
callq 0x3d71
movl %eax, %ebp
movsbl 0x1(%rbx), %edi
callq 0x3d71
movl %ebp, %ecx
shll $0x4, %ecx
orl %eax, %ecx
orl %eax, %ebp
pushq $-0x1
popq %rax
cmovnsl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x4092
callq 0x2320
movq (%rax), %rax
movsbq (%rbx,%r15), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x4092
incq %r15
jmp 0x4073
movzbl (%rbx,%r15), %eax
orl $0x20, %eax
cmpl $0x68, %eax
jne 0x40b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4043
movq %rax, %rbx
incq %rbx
jmp 0x40e0
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 0x40c8
btl $0xa, %edx
jb 0x40e9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movzbl %al, %eax
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0x4128
movabsq $0x3f0000003f, %rcx     # imm = 0x3F0000003F
btq %rax, %rcx
jae 0x4128
leaq 0x7329(%rip), %rdi      # 0xb434
xorl %eax, %eax
callq 0x2af7
incl 0x20914(%rip)           # 0x24a2c
movq %rbx, %rdi
callq 0x2a71
pushq $0x1
popq %rdi
callq 0x22f0
leaq 0x733a(%rip), %rdi      # 0xb469
jmp 0x410b
// File: /workspace/github_c_makefile_star2_O2/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 0x4166
movzbl 0x1(%rdi), %eax
cmpl $0x72, %eax
je 0x4180
cmpl $0x30, %eax
je 0x417c
cmpl $0x61, %eax
je 0x4170
cmpl $0x65, %eax
je 0x4178
cmpl $0x6e, %eax
je 0x4174
cmpl $0x27, %eax
jne 0x4161
cmpb $0x27, 0x3(%rdi)
jne 0x41a9
movsbl %al, %eax
jmp 0x4183
incq %rdi
movl %eax, (%rsi)
movq %rdi, %rax
jmp 0x4195
pushq $0x7
jmp 0x4182
pushq $0xa
jmp 0x4182
pushq $0x1b
jmp 0x4182
xorl %eax, %eax
jmp 0x4183
pushq $0xd
popq %rax
leaq 0x1(%rdi), %rcx
movl %eax, (%rsi)
leaq 0x2(%rdi), %rax
cmpb $0x0, 0x1(%rdi)
cmoveq %rcx, %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x41a1
cmpl $0x27, %ecx
jne 0x41b5
cmpb $0x1, %cl
sbbq $-0x1, %rax
retq
movl $0x5c, (%rsi)
addq $0x2, %rdi
jmp 0x416b
pushq %rax
incl 0x20870(%rip)           # 0x24a2c
leaq 0x72cd(%rip), %rdi      # 0xb490
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rsi)
movq %rdi, %rbx
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
movsbl (%rbx,%rcx), %edi
cmpl $0x4, %ecx
je 0x41fd
cmpb $0x22, %dil
je 0x4203
shll $0x8, %edx
orl %edi, %edx
movl %edx, (%rsi)
decq %rax
incq %rcx
jmp 0x41df
cmpb $0x22, %dil
jne 0x420b
subq %rax, %rbx
incq %rbx
jmp 0x421c
subq %rax, %rbx
leaq 0x72a8(%rip), %rdi      # 0xb4bd
xorl %eax, %eax
callq 0x2af7
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6e03(%rip), %rdx      # 0xb030
movzbl (%rax), %edi
leal -0x2a(%rdi), %r8d
cmpl $0x7, %r8d
ja 0x424d
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
leal 0x1(,%rcx,2), %ecx
jmp 0x4252
cmpl $0x20, %edi
jne 0x4263
cmpl $0x30, %edi
je 0x425c
cmpl $0x2e, %edi
jne 0x425e
addl %ecx, %ecx
incq %rax
jmp 0x422d
movl %ecx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x5d
popq %rax
pushq $0x29
popq %rbx
cmovel %eax, %ebx
incq %rdi
xorl %edx, %edx
callq 0x37d5
movq %rax, %rdi
movl %ebx, %esi
callq 0x2f15
testq %rax, %rax
je 0x42b3
incq %rax
popq %rbx
retq
xorl %edi, %edi
callq 0x2a71
movzbl %bl, %esi
leaq 0x7223(%rip), %rdi      # 0xb4e7
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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 0x31b3
movq %rax, %rbx
cmpb $0x0, 0x1fb74(%rip)     # 0x23fa0
je 0x4464
leaq 0x1fb6b(%rip), %rdi     # 0x23fa0
movq %r15, %rsi
xorl %edx, %edx
callq 0x37d5
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x445b
cmpl $0x28, %ecx
jne 0x4475
incq %rax
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x37d5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2a71
leaq 0x7129(%rip), %rdi      # 0xb59c
jmp 0x4484
movq %rax, %rdi
callq 0x2a71
leaq 0x7141(%rip), %rdi      # 0xb5c5
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/Edilbert[P]BS9/bs9.c
// Function: ParseFillData
char *ParseFillData(char *p)
{
   int i,m,v;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x37d5
movl (%rbx), %ebx
cmpq $0x10000, %rbx          # imm = 0x10000
jae 0x49b0
pushq $0x28
popq %rsi
movq %rax, %rdi
callq 0x2f15
testq %rax, %rax
je 0x49c2
incq %rax
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x37d5
movq %rax, %r14
cmpl $0x0, 0x20186(%rip)     # 0x24a18
movl 0xee9c(%rip), %eax      # 0x13734
jne 0x4994
movzbl 0x8(%rsp), %ebp
movslq %eax, %rcx
xorl %edx, %edx
leaq 0xf3a1(%rip), %rsi      # 0x13c50
cmpq %rdx, %rbx
je 0x48c1
leaq (%rcx,%rdx), %rdi
movb %bpl, (%rsi,%rdi)
incq %rdx
jmp 0x48af
cmpl $0x0, 0xc8f0(%rip)      # 0x111b8
je 0x4994
callq 0x2c8c
movq 0x2012e(%rip), %rcx     # 0x24a08
testq %rbx, %rbx
je 0x492c
leaq 0x6945(%rip), %rsi      # 0xb22b
movq %rcx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
cmpl $0x1, %ebx
je 0x493e
movq 0x2010a(%rip), %rdi     # 0x24a08
leaq 0x6926(%rip), %rsi      # 0xb22b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
cmpl $0x3, %ebx
jb 0x4957
movq 0x200ee(%rip), %rdi     # 0x24a08
leaq 0x690a(%rip), %rsi      # 0xb22b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
jmp 0x4970
leaq 0x7d11(%rip), %rdi      # 0xc644
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
movq 0x200c3(%rip), %rcx     # 0x24a08
leaq 0x7cf8(%rip), %rdi      # 0xc644
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
movq 0x200aa(%rip), %rcx     # 0x24a08
leaq 0x7cdf(%rip), %rdi      # 0xc644
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
movq 0x20091(%rip), %rdi     # 0x24a08
leaq 0x6d23(%rip), %rsi      # 0xb6a1
leaq 0x1f51b(%rip), %rdx     # 0x23ea0
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2210
movl 0xeda0(%rip), %eax      # 0x13734
addl %eax, %ebx
movl %ebx, 0xed98(%rip)      # 0x13734
movq %r14, %rdi
callq 0x2110
addq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6caf(%rip), %rdi      # 0xb666
movl %ebx, %esi
xorl %eax, %eax
callq 0x2af7
jmp 0x49d0
leaq 0x6cb9(%rip), %rdi      # 0xb682
xorl %eax, %eax
callq 0x2af7
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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 0x7f783(%rip), %edi     # 0x84170
testl %edi, %edi
je 0x4a76
cmpl $0x0, 0xc7bc(%rip)      # 0x111b8
je 0x4a76
cmpl $0x0, 0x20013(%rip)     # 0x24a18
jne 0x4a76
callq 0x3119
testl %eax, %eax
js 0x4a67
movl %eax, %ebp
movq 0x1ffef(%rip), %rdi     # 0x24a08
leaq 0x6c91(%rip), %rsi      # 0xb6b1
leaq 0x1f479(%rip), %rdx     # 0x23ea0
xorl %eax, %eax
callq 0x2210
movq 0x1ffd3(%rip), %rdi     # 0x24a08
movl 0xecf9(%rip), %edx      # 0x13734
subl 0x7f72f(%rip), %edx     # 0x84170
movl %ebp, %eax
imulq $0x30, %rax, %rax
leaq 0x1fff2(%rip), %rcx     # 0x24a40
movq (%rax,%rcx), %rcx
leaq 0x6c69(%rip), %rsi      # 0xb6c2
xorl %eax, %eax
callq 0x2210
andl $0x0, 0x7f709(%rip)     # 0x84170
movq 0x1ff9a(%rip), %rsi     # 0x24a08
pushq $0xa
popq %rdi
callq 0x21a0
addq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq