LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x6525
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %r14
incq %rbx
testb $0x20, 0x1(%rax,%r14,2)
jne 0x63c8
movq %rbx, %rdi
callq 0x2110
cmpq $0x7, %rax
jb 0x6525
cmpb $0x22, %r14b
jne 0x6525
cmpb $0x22, 0x6(%rbx)
jne 0x6525
xorl %ebp, %ebp
movl $0x5, %eax
movl $0x4, %ecx
movl $0x40, %edx
movl %ecx, %esi
movzbl (%rbx,%rsi), %esi
cmpb $0x20, %sil
cmovel %edx, %esi
movl $0x5b, %edi
cmpb $0x32, %sil
je 0x6429
movl %esi, %edi
movl $0x5c, %esi
cmpb $0x33, %dil
je 0x6436
movl %edi, %esi
leal -0x5d(%rsi), %edi
cmpb $-0x1f, %dil
jbe 0x6505
movl %ebp, %edi
movzbl %sil, %ebp
shll $0x5, %edi
addl $-0x3f, %ebp
orl %edi, %ebp
decl %eax
decl %ecx
cmpl $0x1, %eax
ja 0x640f
movzbl 0x5(%rbx), %eax
cmpl $0x51, %eax
jg 0x6475
cmpl $0x43, %eax
je 0x6487
cmpl $0x44, %eax
jne 0x6495
orl $0x200000, %ebp         # imm = 0x200000
jmp 0x6495
cmpl $0x52, %eax
je 0x648f
cmpl $0x57, %eax
jne 0x6495
orl $0x400000, %ebp         # imm = 0x400000
jmp 0x6495
orl $0x100000, %ebp         # imm = 0x100000
jmp 0x6495
orl $0x300000, %ebp         # imm = 0x300000
cmpl $0x0, 0x1f57c(%rip)     # 0x25a18
je 0x64a6
movl 0xe290(%rip), %eax      # 0x14734
jmp 0x64f0
cmpl $0x0, 0xbd0b(%rip)      # 0x121b8
je 0x64cd
movq 0x1f552(%rip), %rdi     # 0x25a08
leaq 0x6661(%rip), %rsi      # 0xcb1e
leaq 0x1e9dc(%rip), %rcx     # 0x24ea0
movl %ebp, %edx
xorl %eax, %eax
callq 0x2210
movslq 0xe260(%rip), %rax      # 0x14734
leaq 0xe775(%rip), %rcx      # 0x14c50
addq %rax, %rcx
movl $0x3, %edx
movb %bpl, -0x1(%rcx,%rdx)
sarl $0x8, %ebp
decq %rdx
jne 0x64e3
addl $0x3, %eax
movl %eax, 0xe23b(%rip)      # 0x14734
addq $0x7, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x65ff(%rip), %rdi      # 0xcb0b
xorl %eax, %eax
callq 0x2e72
movq %rbx, %rdi
callq 0x2dde
movl $0x1, %edi
callq 0x22f0
leaq 0x65c6(%rip), %rdi      # 0xcaf2
jmp 0x650c
// File: /workspace/github_c_makefile_star2_O3/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 0x6551
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6542
leaq 0x7ec18(%rip), %rsi     # 0x85170
movq %rbx, %rdi
movl $0x4d, %edx
callq 0x3852
leaq 0x1e834(%rip), %rdi     # 0x24da0
leaq 0x7e9ed(%rip), %rsi     # 0x84f60
callq 0x2090
cmpl $0x0, 0x1f499(%rip)     # 0x25a18
jne 0x65a6
cmpl $0x0, 0xbc30(%rip)      # 0x121b8
je 0x65a6
movq 0x1f477(%rip), %rdi     # 0x25a08
leaq 0x5ceb(%rip), %rsi      # 0xc283
leaq 0x1e901(%rip), %rdx     # 0x24ea0
xorl %eax, %eax
callq 0x2210
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x1f462(%rip)     # 0x25a18
jne 0x65d1
cmpl $0x0, 0xbbf9(%rip)      # 0x121b8
je 0x65d1
callq 0x3014
movq %rbx, %rdi
callq 0x52ce
movq %rax, %rbx
movb $0x0, 0x1e7c8(%rip)     # 0x24da0
movl $0x0, 0x7eb8e(%rip)     # 0x85170
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x677e
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6765
xorl %eax, %eax
cmpb $0x2a, %cl
sete %al
jmp 0x6780
xorl %eax, %eax
leaq (%rbx,%rax), %rdi
movb (%rbx,%rax), %bpl
xorl %eax, %eax
movl $0x12, %ecx
cmpb $0x26, %bpl
sete %al
jne 0x679e
movl 0x7ed1a(%rip), %ecx     # 0x854b8
addq %rax, %rdi
movq %rsp, %rdx
movl %ecx, (%rdx)
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0x4c13
movq %rax, %rbx
movl (%r14), %ecx
movq 0x1f250(%rip), %rdi     # 0x25a10
cmpb $0x26, %bpl
jne 0x682c
movl 0x1f263(%rip), %r9d     # 0x25a30
movl %r9d, %eax
cltd
idivl %ecx
movl %ecx, %eax
subl %edx, %eax
cltd
idivl %ecx
movl %edx, %r14d
testq %rdi, %rdi
je 0x67fb
leal (%r14,%r9), %ecx
movl (%rsp), %r8d
leaq 0x633e(%rip), %rsi      # 0xcb2f
movl %r9d, %edx
xorl %eax, %eax
callq 0x2210
testl %r14d, %r14d
je 0x688c
movslq 0x1f225(%rip), %r15     # 0x25a30
movl (%rsp), %esi
leaq 0xe43b(%rip), %rdi      # 0x14c50
addq %r15, %rdi
movl %r14d, %edx
callq 0x2180
addl %r15d, %r14d
movl %r14d, 0x1f206(%rip)    # 0x25a30
jmp 0x688c
movl 0xdf01(%rip), %r9d      # 0x14734
movl %r9d, %eax
cltd
idivl %ecx
movl %ecx, %eax
subl %edx, %eax
cltd
idivl %ecx
movl %edx, %r14d
testq %rdi, %rdi
je 0x6861
leal (%r14,%r9), %ecx
movl (%rsp), %r8d
leaq 0x62fd(%rip), %rsi      # 0xcb54
movl %r9d, %edx
xorl %eax, %eax
callq 0x2210
testl %r14d, %r14d
je 0x688c
movslq 0xdec7(%rip), %r15      # 0x14734
movl (%rsp), %esi
leaq 0xe3d9(%rip), %rdi      # 0x14c50
addq %r15, %rdi
movl %r14d, %edx
callq 0x2180
addl %r15d, %r14d
movl %r14d, 0xdea8(%rip)     # 0x14734
callq 0x31a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x0, (%rdi)
je 0x68fb
movq %rdi, %rbx
callq 0x2320
movq (%rax), %rax
movb (%rbx), %cl
movsbq %cl, %rdx
incq %rbx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x68ca
cmpb $0x3d, %cl
jne 0x68fb
leaq 0xde4e(%rip), %rsi      # 0x14734
movq %rbx, %rdi
callq 0x352f
movq %rax, %rbx
callq 0x31a3
movq %rbx, %rax
popq %rbx
retq
incl 0x1f12b(%rip)           # 0x25a2c
leaq 0x6271(%rip), %rdi      # 0xcb79
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/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 0x352f
movl (%r14), %ebp
testl %ebp, %ebp
js 0x6957
movq %rax, %rbx
callq 0x31a3
addl %ebp, 0xddf1(%rip)      # 0x14734
movq %rbx, %rdi
callq 0x2110
addq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6247(%rip), %rdi      # 0xcba5
movl %ebp, %esi
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/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 0x6282(%rip), %rsi      # 0xcbfe
callq 0x2969
testq %rax, %rax
je 0x699b
addq $0x4, %rax
leaq 0xdda3(%rip), %rsi      # 0x14734
movq %rax, %rdi
xorl %edx, %edx
callq 0x3e17
callq 0x31a3
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7eb0f(%rip), %rsi     # 0x854bc
callq 0x352f
movq %rax, %rbx
movl 0x7eb01(%rip), %edi     # 0x854bc
cmpl $0x100, %edi            # imm = 0x100
jl 0x69cc
shrl $0x8, %edi
movl %edi, 0x7eaf0(%rip)     # 0x854bc
callq 0x31d9
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6a00
callq 0x2320
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x69f1
movl $0x8, %r15d
leaq 0xe003(%rip), %r12      # 0x14a10
movq -0x8(%r15,%r12), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2cd8
testl %eax, %eax
je 0x6a30
addq $0x10, %r15
cmpq $0x228, %r15            # imm = 0x228
jne 0x6a0d
jmp 0x6a53
movq (%r15,%r12), %r15
movq %r14, %rdi
callq 0x2110
addq %rax, %rbx
movq %rbx, %rdi
callq *%r15
cmpl $0x10001, 0xdce5(%rip)  # imm = 0x10001
jge 0x6a62
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x624b(%rip), %rdi      # 0xccb7
xorl %eax, %eax
callq 0x2e72
movq %rbx, %rdi
callq 0x2dde
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/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 0xb296(%rip), %rcx      # 0x121c0
leaq (%rcx,%rax,8), %rbx
leaq 0x5ec6(%rip), %rsi      # 0xcdfb
movq %rbx, %rdi
movl $0x4, %edx
callq 0x2c53
movl $0x1, %ebp
testl %eax, %eax
je 0x6f8e
leaq 0x5eae(%rip), %rsi      # 0xce00
movq %rbx, %rdi
movl $0x4, %edx
callq 0x2c53
testl %eax, %eax
je 0x6f8e
movq %rbx, %rdi
callq 0x2110
movsbl -0x1(%rax,%rbx), %esi
leal -0x41(%rsi), %eax
cmpb $0x19, %al
jae 0x6f97
movzbl %al, %eax
movl $0x1d5003f, %ecx        # imm = 0x1D5003F
btl %eax, %ecx
jae 0x6f97
leaq 0x51d5(%rip), %rcx      # 0xc160
movl (%rcx,%rax,4), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5e67(%rip), %rdi      # 0xce05
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/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 0xd6f5(%rip), %r13      # 0x146c0
movq (%r13,%r12,8), %r15
movq %r15, %rdi
callq 0x2110
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x2c53
testl %eax, %eax
je 0x700f
addq $-0x1, %r12
jb 0x6fcb
movq %rbx, %rdi
callq 0x2dde
leaq 0x5e23(%rip), %rdi      # 0xce21
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
movl %r12d, (%r14)
movq (%r13,%r12,8), %rdi
callq 0x2110
movq %rax, %r14
cmpb $0x0, (%rbx,%rax)
je 0x704c
callq 0x2320
movq (%rax), %rax
addq %r14, %rbx
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7033
xorl %eax, %eax
cmpb $0x2c, %cl
sete %al
jmp 0x7051
addq %r14, %rbx
xorl %eax, %eax
addq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd650(%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 0x70b6
addl $-0x1, %eax
jb 0x7084
movq %rbx, %rdi
callq 0x2dde
leaq 0x5da4(%rip), %rdi      # 0xce49
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
movl %eax, (%r14)
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e960(%rip)           # 0x25a2c
callq 0x2dde
leaq 0x5da1(%rip), %rdi      # 0xce79
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/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 0x710d
addl $-0x73, %eax
cmpl $0x6, %eax
ja 0x713a
leaq 0x5028(%rip), %rcx      # 0xc12c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ffc(%rip), %rax      # 0xc110
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x60, %eax
jmp 0x7134
xorl %eax, %eax
jmp 0x7134
movl $0x20, %eax
jmp 0x7134
movl $0x40, %eax
testl %edi, %edi
jns 0x713a
popq %rcx
retq
movq %rsi, %rdi
callq 0x70c5
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ScanPushList
int ScanPushList(char *p)
{
   int i,l,v;
   char *Reg;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x5797(%rip), %rsi      # 0xcf7d
callq 0x2cd8
testl %eax, %eax
je 0x7903
cmpb $0x0, (%r12)
je 0x790b
movq 0x1e20b(%rip), %rbx     # 0x25a10
xorl %r13d, %r13d
movl %r13d, 0x4(%rsp)
movq $-0xa, %r14
leaq 0xcefd(%rip), %r15      # 0x14718
movq %rbx, %r13
movq %r15, %rdi
callq 0x2110
movq %rax, %rbp
testq %r13, %r13
je 0x7851
movq %r13, %rdi
leaq 0x5749(%rip), %rsi      # 0xcf81
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2210
movq 0x1e1c4(%rip), %rbx     # 0x25a10
movq %rbx, %r13
jmp 0x7854
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rsi
callq 0x2cd8
testl %eax, %eax
je 0x7871
addq $-0x8, %r15
incq %r14
jne 0x781e
jmp 0x7920
movl 0x4(%rsp), %r13d
orl 0x4(%r15), %r13d
movslq %ebp, %rax
leaq (%r12,%rax), %r15
movsbq (%r12,%rax), %r14
testq %r14, %r14
je 0x78b5
callq 0x2320
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
je 0x78a5
movsbq 0x1(%r15), %r14
incq %r15
jmp 0x7893
testb %r14b, %r14b
je 0x78b8
movzbl %r14b, %eax
cmpl $0x2c, %eax
je 0x78b8
jmp 0x7928
xorl %r14d, %r14d
xorl %eax, %eax
cmpb $0x2c, %r14b
sete %al
movsbq (%r15,%rax), %r14
testq %r14, %r14
je 0x790e
addq %rax, %r15
callq 0x2320
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0x78e2
xorl %eax, %eax
jmp 0x78f6
movsbq 0x1(%r15), %rcx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x78e2
testb %cl, %cl
sete %al
movq %r15, %r12
testb %al, %al
je 0x7808
jmp 0x790e
movl $0xff, %r13d
jmp 0x790e
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x70c5
movq %r15, %rdi
callq 0x70c5
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ScanArguments
int ScanArguments(char *p, char *args, int ptr[], int nargs)
{
   int l,n;
   char sym[ML];

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, %r12
movq 0x1cf6d(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x8abb
leaq 0x48e1(%rip), %rsi      # 0xd390
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2210
movl $0x0, (%r14)
xorl %r15d, %r15d
testl %ebx, %ebx
jle 0x8c0d
cmpb $0x0, (%r12)
je 0x8c0d
leal -0x1(%rbx), %eax
movq %rax, 0x8(%rsp)
movl %ebx, %eax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movq 0x1cf1f(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x8b11
leaq 0x48a6(%rip), %rsi      # 0xd3a3
movl %r13d, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2210
cmpb $0x0, (%r12)
je 0x8b3b
callq 0x2320
movq (%rax), %rax
decq %r12
movsbq 0x1(%r12), %rcx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8b1c
cmpb $0x29, %cl
leaq 0x20(%rsp), %r15
jne 0x8b40
jmp 0x8c0a
leaq 0x20(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
cmpl $0xa, %ebx
jne 0x8b52
callq 0x2a9c
jmp 0x8b57
callq 0x2b4c
movq %rax, %rbp
movq %r15, %rdi
callq 0x2110
movq %rax, %r12
movslq (%r14,%r13,4), %rdi
addq 0x18(%rsp), %rdi
testl %r12d, %r12d
je 0x8b85
movl %r12d, %eax
incl %eax
movslq %eax, %rdx
movq %r15, %rsi
callq 0x2250
jmp 0x8b88
movb $0x0, (%rdi)
leaq 0x1(%r13), %r15
movl (%r14,%r13,4), %eax
addl %r12d, %eax
incl %eax
movl %eax, 0x4(%r14,%r13,4)
movsbq (%rbp), %r12
testq %r12, %r12
je 0x8bcf
callq 0x2320
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
je 0x8bbe
movsbq 0x1(%rbp), %r12
incq %rbp
jmp 0x8bac
cmpb $0x2c, %r12b
je 0x8be4
movzbl %r12b, %eax
cmpl $0x29, %eax
jne 0x8bd2
jmp 0x8c0d
xorl %r12d, %r12d
cmpl $0xa, %ebx
setae %al
cmpq 0x8(%rsp), %r15
setae %cl
orb %al, %cl
je 0x8c22
xorl %eax, %eax
cmpb $0x2c, %r12b
sete %cl
cmpq 0x10(%rsp), %r15
jae 0x8c0d
movb %cl, %al
leaq (%rax,%rbp), %r12
cmpb $0x0, (%rbp,%rax)
movq %r15, %r13
jne 0x8aea
jmp 0x8c0d
movq %r13, %r15
movl %r15d, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl 0x1ce04(%rip)           # 0x25a2c
movsbl (%rbp), %esi
leaq 0x477e(%rip), %rdi      # 0xd3b1
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ScanArgs
int ScanArgs(char *p, char *args, int ptr[])
{
   int l,n;
   char sym[ML];

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, 0x8(%rsp)
movl $0x0, (%rdx)
cmpb $0x0, (%rdi)
je 0x8d1d
movq %rdx, %rbx
movq %rdi, %r15
callq 0x2320
movq %rax, %r12
movq (%rax), %rcx
xorl %eax, %eax
leaq 0x10(%rsp), %r13
movq %rax, %r14
decq %r15
movsbq 0x1(%r15), %rax
incq %r15
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x8c87
cmpb $0x3b, %al
je 0x8d21
movq %r15, %rdi
movq %r13, %rsi
callq 0x2bad
movq %rax, %r15
movq %r13, %rdi
callq 0x2110
movq %rax, %rbp
movslq (%rbx,%r14,4), %rdi
addq 0x8(%rsp), %rdi
testl %ebp, %ebp
je 0x8cd5
movl %ebp, %eax
incl %eax
movslq %eax, %rdx
movq %r13, %rsi
callq 0x2250
jmp 0x8cd8
movb $0x0, (%rdi)
leaq 0x1(%r14), %rax
movl (%rbx,%r14,4), %ecx
addl %ebp, %ecx
incl %ecx
movl %ecx, 0x4(%rbx,%r14,4)
movsbq (%r15), %rdx
testq %rdx, %rdx
je 0x8d24
movq (%r12), %rcx
incq %r15
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x8d06
movsbq (%r15), %rdx
jmp 0x8cf6
cmpb $0x2c, %dl
jne 0x8d24
cmpq $0x8, %r14
ja 0x8d24
cmpb $0x0, (%r15)
jne 0x8c81
jmp 0x8d24
xorl %eax, %eax
jmp 0x8d24
movq %r14, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: MacroInfo
void MacroInfo(int n)
{
   fprintf(df,"-----------------\n");
   fprintf(df,"Name: %s\n",Mac[n].Name);
   fprintf(df,"Args: %d\n",Mac[n].Narg);
   fprintf(df,"Cola: %d\n",Mac[n].Cola);
   fprintf(df,"Type: %d\n",Mac[n].Type);
   fprintf(df,"Body: <<<%s>>>\n",Mac[n].Body);
   fprintf(df,"-----------------\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
movq 0x1ccca(%rip), %rcx     # 0x25a10
leaq 0x468b(%rip), %rbx      # 0xd3d8
movl $0x12, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2300
movq 0x1ccaa(%rip), %rdi     # 0x25a10
movslq %ebp, %r14
shlq $0x5, %r14
leaq 0x7a8dc(%rip), %r15     # 0x83650
movq (%r14,%r15), %rdx
leaq 0x466c(%rip), %rsi      # 0xd3eb
xorl %eax, %eax
callq 0x2210
movq 0x1cc83(%rip), %rdi     # 0x25a10
movl 0x10(%r14,%r15), %edx
leaq 0x465c(%rip), %rsi      # 0xd3f5
xorl %eax, %eax
callq 0x2210
movq 0x1cc69(%rip), %rdi     # 0x25a10
movl 0x14(%r14,%r15), %edx
leaq 0x464c(%rip), %rsi      # 0xd3ff
xorl %eax, %eax
callq 0x2210
movq 0x1cc4f(%rip), %rdi     # 0x25a10
movl 0x18(%r14,%r15), %edx
leaq 0x463c(%rip), %rsi      # 0xd409
xorl %eax, %eax
callq 0x2210
movq 0x1cc35(%rip), %rdi     # 0x25a10
movq 0x8(%r14,%r15), %rdx
leaq 0x462c(%rip), %rsi      # 0xd413
xorl %eax, %eax
callq 0x2210
movq 0x1cc1b(%rip), %rcx     # 0x25a10
movl $0x12, %esi
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2300
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ExpandMacro
int ExpandMacro(char *m)
{
   int j,an;
   char *p;
   char Macro[ML];

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %r14
callq 0x363f
movl %eax, %ebx
testl %eax, %eax
js 0x951c
movq 0x1c613(%rip), %rdi     # 0x25a10
movl %ebx, %r12d
testq %rdi, %rdi
je 0x942b
movq %r12, %rax
shlq $0x5, %rax
leaq 0x7a23d(%rip), %rcx     # 0x83650
movq (%rax,%rcx), %rdx
movl 0x1c5fb(%rip), %ecx     # 0x25a18
leaq 0x409d(%rip), %rsi      # 0xd4c1
xorl %eax, %eax
callq 0x2210
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2bad
movq %rax, %r15
cmpb $0x0, (%rax)
je 0x9463
callq 0x2320
movq (%rax), %rax
decq %r15
movsbq 0x1(%r15), %rcx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x9449
xorl %edi, %edi
cmpb $0x28, %cl
sete %dil
jmp 0x9465
xorl %edi, %edi
addq %r15, %rdi
callq 0x36db
shlq $0x5, %r12
leaq 0x7a1d8(%rip), %r15     # 0x83650
movl 0x10(%r12,%r15), %ecx
leaq 0x1bb1c(%rip), %rdi     # 0x24fa0
leaq 0x7e355(%rip), %rsi     # 0x877e0
leaq 0x7e44e(%rip), %rdx     # 0x878e0
callq 0x8a7e
movl 0x10(%r12,%r15), %ecx
cmpl %ecx, %eax
jne 0x952d
addq %r12, %r15
movslq 0x7e45a(%rip), %rax     # 0x87908
leaq 0x1(%rax), %rdx
movl %edx, 0x7e450(%rip)     # 0x87908
movq 0x8(%r15), %rcx
leaq 0x7e44d(%rip), %rsi     # 0x87910
movq %rcx, 0x8(%rsi,%rax,8)
movq 0x1c541(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x9500
leaq 0x4037(%rip), %rsi      # 0xd512
xorl %eax, %eax
callq 0x2210
movq 0x1c527(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x9500
movq 0x8(%r15), %rdx
leaq 0x4029(%rip), %rsi      # 0xd522
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x1c511(%rip)     # 0x25a18
jne 0x951c
leaq 0x1b990(%rip), %rax     # 0x24ea0
subl %eax, %r14d
movl %r14d, 0x14(%r15)
callq 0x314b
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
incl 0x1c4f9(%rip)           # 0x25a2c
leaq 0x3fa1(%rip), %rdi      # 0xd4db
movq %rsp, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2e72
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: NextMacLine
void NextMacLine(char *w)
{
   int i;
   char *r;

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

   // do not count macro expansion lines

   --LiNo;

   // check for end of macro body

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c4b2(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x9574
leaq 0x3fce(%rip), %rsi      # 0xd538
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2210
decl 0x1b7de(%rip)           # 0x24d58
movl 0x7e388(%rip), %eax     # 0x87908
leaq 0x7e389(%rip), %r14     # 0x87910
testl %eax, %eax
jle 0x95aa
movl %eax, %ecx
movq (%r14,%rcx,8), %rcx
cmpb $0x0, (%rcx)
jne 0x95aa
leal -0x1(%rax), %edx
movl %edx, 0x7e369(%rip)     # 0x87908
cmpl $0x1, %eax
movl %edx, %eax
jg 0x958b
xorl %eax, %eax
jmp 0x95ac
movl %eax, %edx
movq 0x1c45d(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x95d3
movslq %eax, %rdx
movq (%r14,%rdx,8), %rcx
leaq 0x3f86(%rip), %rsi      # 0xd54c
xorl %eax, %eax
callq 0x2210
movl 0x7e335(%rip), %edx     # 0x87908
movslq %edx, %rax
movq (%r14,%rax,8), %rsi
testq %rsi, %rsi
je 0x968b
movb (%rsi), %r9b
testb %r9b, %r9b
je 0x968b
leaq 0x7e2ea(%rip), %rax     # 0x878e0
leaq 0x7e1e3(%rip), %rcx     # 0x877e0
movslq %edx, %rdi
cmpb $0x60, %r9b
je 0x962f
movzbl %r9b, %edx
testl %edx, %edx
je 0x968b
cmpl $0xa, %edx
je 0x9684
leaq 0x1(%rsi), %rdx
movq %rdx, (%r14,%rdi,8)
movb (%rsi), %dl
movb %dl, (%rbx)
incq %rbx
movslq 0x7e2df(%rip), %rdx     # 0x87908
movq (%r14,%rdx,8), %r8
jmp 0x9679
leaq 0x1(%rsi), %r8
movq %r8, (%r14,%rdi,8)
movsbq 0x1(%rsi), %rsi
movslq -0xc0(%rax,%rsi,4), %r9
movb (%r9,%rcx), %sil
testb %sil, %sil
je 0x9672
leaq (%r9,%rcx), %rdx
incq %rdx
movb %sil, (%rbx)
incq %rbx
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x9654
movl 0x7e29d(%rip), %edx     # 0x87908
movslq %edx, %rdi
movq (%r14,%rdi,8), %r8
incq %r8
movq %r8, (%r14,%rdi,8)
movb (%r8), %r9b
movq %r8, %rsi
jmp 0x95fd
incq %rsi
movq %rsi, (%r14,%rdi,8)
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: Phase1Listing
void Phase1Listing(void)
{
   fprintf(df,"%5d %4.4x",LiNo,pc);
   if (Label[0]) fprintf(df,"  Label:[%s]{%4.4x}",Label,lab[LabelIndex(Label)].Address);
   if (Comment[0]) fprintf(df,"  %s",Comment);
   fprintf(df,"\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1bd9a(%rip), %rdi     # 0x25a10
movl 0x1b0dc(%rip), %edx     # 0x24d58
movl 0xaab2(%rip), %ecx      # 0x14734
leaq 0x3938(%rip), %rsi      # 0xd5c1
xorl %eax, %eax
callq 0x2210
cmpb $0x0, 0x7b2c9(%rip)     # 0x84f60
je 0x9cd8
movq 0x1bd70(%rip), %rbx     # 0x25a10
leaq 0x7b2b9(%rip), %r14     # 0x84f60
movq %r14, %rdi
callq 0x35bd
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
leaq 0x1bd80(%rip), %rcx     # 0x25a40
movl 0xc(%rax,%rcx), %ecx
leaq 0x3900(%rip), %rsi      # 0xd5cb
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
cmpb $0x0, 0x7e271(%rip)     # 0x87f50
je 0x9cfd
movq 0x1bd28(%rip), %rdi     # 0x25a10
leaq 0x2a3e(%rip), %rsi      # 0xc72d
leaq 0x7e25a(%rip), %rdx     # 0x87f50
xorl %eax, %eax
callq 0x2210
movq 0x1bd0c(%rip), %rsi     # 0x25a10
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: CloseInclude
int CloseInclude(void)
{
   const char *msg = "Close INCLUDE file";

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

// Assembly:
pushq %rbx
cmpl $0x0, 0x1b03f(%rip)     # 0x24d5c
je 0x9d3a
movq 0x1bce2(%rip), %rdi     # 0x25a08
movl 0x1b02c(%rip), %edx     # 0x24d58
leaq 0x2537(%rip), %rsi      # 0xc26a
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x1bcd7(%rip)     # 0x25a18
jne 0x9d8c
cmpl $0x0, 0x846e(%rip)      # 0x121b8
je 0x9d78
movq 0x1bcb5(%rip), %rdi     # 0x25a08
movslq 0x1bca6(%rip), %rax     # 0x25a00
leaq (%rax,%rax,2), %rax
leaq 0x1b33b(%rip), %rcx     # 0x250a0
movq 0x10(%rcx,%rax,8), %rdx
leaq 0x3881(%rip), %rsi      # 0xd5f2
xorl %eax, %eax
callq 0x2210
movq 0x1bc89(%rip), %rdi     # 0x25a08
callq 0x20b0
testl %eax, %eax
jne 0x9e0e
movq 0x7b3e5(%rip), %rdi     # 0x85178
callq 0x2100
testl %eax, %eax
jne 0x9e09
movslq 0x1bc5d(%rip), %rax     # 0x25a00
leaq (%rax,%rax,2), %rax
leaq 0x1b2f2(%rip), %rbx     # 0x250a0
movq 0x10(%rbx,%rax,8), %rdi
callq 0x2040
movslq 0x1bc41(%rip), %rax     # 0x25a00
decq %rax
movl %eax, 0x1bc38(%rip)     # 0x25a00
leaq (%rax,%rax,2), %rax
movq (%rbx,%rax,8), %rdx
movq %rdx, 0x7b3a1(%rip)     # 0x85178
movl 0x8(%rbx,%rax,8), %eax
movl %eax, 0x1af77(%rip)     # 0x24d58
leaq 0x1b0b8(%rip), %rdi     # 0x24ea0
movl $0x100, %esi            # imm = 0x100
callq 0x21c0
movl $0x0, 0x7b6b4(%rip)     # 0x854b0
movq 0x7b375(%rip), %rdi     # 0x85178
popq %rbx
jmp 0x2230
callq 0x23d6
callq 0x23c1
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ListSymbols
void ListSymbols(FILE *lf, int n, int lb, int ub)
{
   int i,j,l;
   char A;

   if (!ListOn) return;
   for (i=0 ; i < n && i < Labels; ++i)
   if (lab[i].Address >= lb && lab[i].Address <= ub)
   {
      fprintf(lf,"%-30.30s $%4.4x",lab[i].Name,lab[i].Address);
      if (lab[i].Locked) fprintf(lf," L");
      else               fprintf(lf,"  ");
      for (j=0 ; j <= lab[i].NumRef ; ++j)
      {
         if (j > 0 && (j % 5) == 0)
         fprintf(lf,"\n                                    ");
         fprintf(lf,"%6d",lab[i].Ref[j]);
         l = lab[i].Att[j];
         if (l == LDEF || l == LBSS || l == LPOS) A = 'D';
         else  A = ' ';
         if ((A != ' ' || (j % 5) != 4) && j != lab[i].NumRef)
            fprintf(lf,"%c",A);
      }
      fprintf(lf,"\n");
   }
}

// Assembly:
cmpl $0x0, 0x7ed5(%rip)      # 0x121b8
je 0xa4a9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r8d
movq %rdi, %r14
testl %esi, %esi
setg %cl
movl 0x1b72c(%rip), %eax     # 0x25a34
testl %eax, %eax
setg %dil
andb %cl, %dil
cmpb $0x1, %dil
jne 0xa49b
movl %esi, %r9d
leaq 0x1b71b(%rip), %r10     # 0x25a40
leaq 0x338c(%rip), %r13      # 0xd6b8
xorl %ebp, %ebp
movl %r8d, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %r9, 0x10(%rsp)
leaq (,%rbp,2), %r15
addq %rbp, %r15
shlq $0x4, %r15
movl 0xc(%r15,%r10), %ecx
cmpl %edx, %ecx
setl %dil
cmpl %r8d, %ecx
setg %sil
orb %dil, %sil
jne 0xa487
addq %r10, %r15
movq (%r15), %rdx
movq %r14, %rdi
leaq 0x3309(%rip), %rsi      # 0xd67f
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x14(%r15)
leaq 0x3306(%rip), %rdi      # 0xd68f
leaq 0x3325(%rip), %rax      # 0xd6b5
cmoveq %rax, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2300
cmpl $0x0, 0x18(%r15)
js 0xa45f
xorl %r12d, %r12d
movl %r12d, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %ebx
negl %ebx
testq %r12, %r12
je 0xa3ef
leaq (%r12,%rbx), %rax
testl %eax, %eax
jne 0xa3ef
movl $0x25, %esi
movl $0x1, %edx
leaq 0x32ab(%rip), %rdi      # 0xd692
movq %r14, %rcx
callq 0x2300
addq %r12, %rbx
addq $-0x4, %rbx
movq 0x20(%r15), %rax
movl (%rax,%r12,4), %edx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x2210
movq 0x28(%r15), %rax
movl (%rax,%r12,4), %eax
addl $-0x4, %eax
cmpl $-0x3, %eax
setb %dl
testl %ebx, %ebx
sete %sil
movl 0x18(%r15), %ecx
testb %dl, %sil
jne 0xa44b
cmpq %rcx, %r12
je 0xa44b
movl $0x20, %edi
cmpl $-0x3, %eax
jb 0xa43f
movl $0x44, %edi
movq %r14, %rsi
callq 0x21a0
movl 0x18(%r15), %ecx
leaq 0x1(%r12), %rax
movslq %ecx, %rcx
cmpq %rcx, %r12
movq %rax, %r12
jl 0xa3b4
movl $0xa, %edi
movq %r14, %rsi
callq 0x21a0
movl 0x1b5c2(%rip), %eax     # 0x25a34
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %r9
leaq 0x1b5b9(%rip), %r10     # 0x25a40
incq %rbp
cmpq %r9, %rbp
jae 0xa49b
movslq %eax, %rcx
cmpq %rcx, %rbp
jl 0xa33c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: PrintSymbols
void PrintSymbols(void)
{
   int i;

   fprintf(yf,"%5d\n",Labels);
   for (i=0 ; i < Labels; ++i)
   {
      if (lab[i].Type == 0) lab[i].Type = ' ';
      fprintf(yf,"%c %4.4x %s\n",lab[i].Type,lab[i].Address,lab[i].Name);
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x7db9a(%rip), %rdi     # 0x88050
movl 0x1b578(%rip), %edx     # 0x25a34
leaq 0x2c7c(%rip), %rsi      # 0xd13f
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x1b563(%rip)     # 0x25a34
jle 0xa521
leaq 0x1b572(%rip), %r14     # 0x25a4c
leaq 0x31db(%rip), %rbx      # 0xd6bc
xorl %r15d, %r15d
movb -0x4(%r14), %al
testb %al, %al
jne 0xa4f3
movb $0x20, -0x4(%r14)
movb $0x20, %al
movq 0x7db56(%rip), %rdi     # 0x88050
movsbl %al, %edx
movl (%r14), %ecx
movq -0xc(%r14), %r8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2210
incq %r15
movslq 0x1b51c(%rip), %rax     # 0x25a34
addq $0x30, %r14
cmpq %rax, %r15
jl 0xa4e4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ListUndefinedSymbols
void ListUndefinedSymbols(void)
{
   int i;

   for (i=0 ; i < Labels ; ++i)
   {
      if (lab[i].Address == UNDEF)
      {
         printf("* Undefined   : %-25.25s *\n",lab[i].Name);
         ++ErrNum;
      }
   }
}

// Assembly:
movl 0x1b507(%rip), %eax     # 0x25a34
testl %eax, %eax
jle 0xa57e
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1b503(%rip), %r14     # 0x25a40
leaq 0x3185(%rip), %rbx      # 0xd6c9
xorl %r15d, %r15d
cmpl $0xff0000, 0xc(%r14)    # imm = 0xFF0000
jne 0xa56a
movq (%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2130
incl 0x1b4c8(%rip)           # 0x25a2c
movl 0x1b4ca(%rip), %eax     # 0x25a34
incq %r15
movslq %eax, %rcx
addq $0x30, %r14
cmpq %rcx, %r15
jl 0xa547
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: WriteBinaryFormat
void WriteBinaryFormat(int i)
{
    unsigned char lo,hi;
    FILE *bf;
    const char *msg = "Write binary";

    if (df) fprintf(df,"Storing $%4.4x - $%4.4x <%s>\n",
                    SFA[i],SFA[i]+SFL[i],SFF[i]);
    bf = AssertFileOp(fopen(SFF[i],"wb"), msg);
    if (SFE[i] > -1)
    {
       lo = SFA[i] & 0xff;
       hi = SFA[i]  >>  8;
       if (fwrite(&hi,1,1,bf) < 1) AssertFileOp(NULL, msg);
       if (fwrite(&lo,1,1,bf) < 1) AssertFileOp(NULL, msg);
    }
    if (fwrite(ROM+SFA[i],1,SFL[i],bf) < (size_t)SFL[i]) AssertFileOp(NULL, msg);
    if (fclose(bf)) AssertFileOp(NULL, msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %eax
movq 0x1b43e(%rip), %rdi     # 0x25a10
movslq %eax, %r14
testq %rdi, %rdi
je 0xa60b
leaq 0x7ac9f(%rip), %rax     # 0x85280
movl (%rax,%r14,4), %edx
leaq 0x7ace4(%rip), %rax     # 0x852d0
movl (%rax,%r14,4), %ecx
addl %edx, %ecx
leaq 0x7ad77(%rip), %rax     # 0x85370
movq (%rax,%r14,8), %r8
leaq 0x30ee(%rip), %rsi      # 0xd6f2
xorl %eax, %eax
callq 0x2210
leaq 0x7ad5e(%rip), %rax     # 0x85370
movq (%rax,%r14,8), %rdi
leaq 0x30f3(%rip), %rsi      # 0xd710
callq 0x22b0
testq %rax, %rax
je 0xa6d3
movq %rax, %rbx
leaq 0x7aceb(%rip), %rax     # 0x85320
cmpl $0x0, (%rax,%r14,4)
js 0xa687
leaq 0x7ac3d(%rip), %rax     # 0x85280
movl (%rax,%r14,4), %eax
movb %al, 0xf(%rsp)
movb %ah, 0xe(%rsp)
leaq 0xe(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2300
testq %rax, %rax
je 0xa6e2
leaq 0xf(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2300
testq %rax, %rax
je 0xa6e7
leaq 0x7abf2(%rip), %rax     # 0x85280
movslq (%rax,%r14,4), %rax
leaq 0xa5b7(%rip), %rdi      # 0x14c50
addq %rax, %rdi
leaq 0x7ac2d(%rip), %r15     # 0x852d0
movslq (%r15,%r14,4), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x2300
movslq (%r15,%r14,4), %rcx
cmpq %rcx, %rax
jb 0xa6d8
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0xa6dd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x243f
callq 0x2400
callq 0x23eb
callq 0x242a
callq 0x2415
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: Checksum
int Checksum(int start, int n)
{
   int sum = 0;
   int i;
   for (i=start ; i < start+n-1 ; i+=2)
      sum += (ROM[i] << 8) | ROM[i+1];
   return sum & 0xffff;
}

// Assembly:
leal (%rdi,%rsi), %edx
decl %edx
xorl %eax, %eax
cmpl %edi, %edx
jle 0xa71f
movslq %edi, %rcx
movslq %edx, %rdx
xorl %eax, %eax
leaq 0xa54a(%rip), %rsi      # 0x14c50
movzwl (%rcx,%rsi), %edi
rolw $0x8, %di
movzwl %di, %edi
addl %edi, %eax
addq $0x2, %rcx
cmpq %rdx, %rcx
jl 0xa706
movzwl %ax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: WriteSparrowFormat
void WriteSparrowFormat(int i)
{
    int Start,Length,Check;
    unsigned char Head[8];
    FILE *bf;
    const char *msg = "Write Sparrow binary";

    Start  = SFA[i];
    Length = SFL[i];
    Check  = Checksum(Start,Length);

    if (df) fprintf(df,"Storing $%4.4x - $%4.4x <%s>\n",
                    Start,Start+Length-1,SFF[i]);
    Head[0] = 'S';
    Head[1] =  Start  >> 16;
    Head[2] = (Start  >>  8) & 0xff;
    Head[3] = (Start       ) & 0xff;
    Head[4] = Length  >>  8;
    Head[5] = Length  & 0xff;
    Head[6] = Check   >>  8;
    Head[7] = Check   & 0xff;

    bf = AssertFileOp(fopen(SFF[i],"wb"), msg);
    if (fwrite(Head,1,8,bf) < 8) AssertFileOp(NULL, msg);
    if (fwrite(ROM+Start,1,Length,bf) < (size_t)Length) AssertFileOp(NULL, msg);
    if (fclose(bf)) AssertFileOp(NULL, msg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %r15
leaq 0x7ab4b(%rip), %rax     # 0x85280
movslq (%rax,%r15,4), %rdx
leaq 0x7ab90(%rip), %rax     # 0x852d0
movslq (%rax,%r15,4), %rax
movq %rax, %r12
leal (%rdx,%rax), %ecx
decl %ecx
xorl %ebx, %ebx
leaq 0xa4fb(%rip), %r14      # 0x14c50
movq %rdx, %r13
cmpl %edx, %ecx
jle 0xa77b
movslq %ecx, %rax
xorl %ebx, %ebx
movq %r13, %rdx
movzwl (%rdx,%r14), %esi
rolw $0x8, %si
movzwl %si, %esi
addl %esi, %ebx
addq $0x2, %rdx
cmpq %rax, %rdx
jl 0xa764
movq 0x1b28e(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
movq %r13, %rdx
je 0xa7a9
leaq 0x7abdf(%rip), %rax     # 0x85370
movq (%rax,%r15,8), %r8
leaq 0x2f56(%rip), %rsi      # 0xd6f2
movq %rdx, %rbp
xorl %eax, %eax
callq 0x2210
movq %rbp, %rdx
movb $0x53, (%rsp)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x1(%rsp)
movb %dh, 0x2(%rsp)
movb %dl, 0x3(%rsp)
movq %r12, %rax
movb %ah, 0x4(%rsp)
movb %al, 0x5(%rsp)
movb %bh, 0x6(%rsp)
movb %bl, 0x7(%rsp)
leaq 0x7ab98(%rip), %rax     # 0x85370
movq (%rax,%r15,8), %rdi
leaq 0x2f2d(%rip), %rsi      # 0xd710
callq 0x22b0
testq %rax, %rax
je 0xa841
movq %rax, %r15
movq %rsp, %rdi
movl $0x1, %esi
movl $0x8, %edx
movq %rax, %rcx
callq 0x2300
cmpq $0x7, %rax
jbe 0xa846
addq %r13, %r14
movl $0x1, %esi
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2300
cmpq %r12, %rax
jb 0xa84b
movq %r15, %rdi
callq 0x2100
testl %eax, %eax
jne 0xa850
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2493
callq 0x247e
callq 0x2469
callq 0x2454
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: WriteS19Line
void WriteS19Line(FILE *bf, const char *RecordType, int PayloadSize, int Address, unsigned char *Data)
{
   int i,Checksum;
   const char *msg = "Write S19 record";

   fprintf(bf, "%s", RecordType);
   // 3 extra bytes for address and checksum
   Checksum = PayloadSize + 3 + (Address & 0xff) + (Address >> 8);
   fprintf(bf, "%02X%04X", PayloadSize + 3, Address);
   if (ferror(bf)) AssertFileOp(NULL, msg);
   for (i=0; i < PayloadSize; ++i)
   {
      fprintf(bf, "%02X", Data[i]);
      if (ferror(bf)) AssertFileOp(NULL, msg);
      Checksum += Data[i];
   }
   // Force CR LF line endings for ancient EPROM programmers
   fprintf(bf, "%02X\r\n", ~Checksum & 0xff);
   if (ferror(bf)) AssertFileOp(NULL, msg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x2170
leal 0x3(%r15), %r12d
leaq 0x2eb8(%rip), %rsi      # 0xd739
movq %rbx, %rdi
movl %r12d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
jne 0xa91b
addl %ebp, %r12d
sarl $0x8, %ebp
addl %r12d, %ebp
testl %r15d, %r15d
jle 0xa8e4
movl %r15d, %r12d
leaq 0x2e8e(%rip), %r15      # 0xd742
xorl %r13d, %r13d
movzbl (%r14,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
jne 0xa916
movzbl (%r14,%r13), %eax
addl %eax, %ebp
incq %r13
cmpq %r13, %r12
jne 0xa8b7
notl %ebp
movzbl %bpl, %edx
leaq 0x2e56(%rip), %rsi      # 0xd747
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
jne 0xa920
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24bd
callq 0x24a8
callq 0x24d2
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: WriteBinaries
void WriteBinaries(void)
{
   int i;

   for (i=0 ; i < StoreCount ; ++i)
   {
           if (SFT[i] == SRECORD) WriteS19Format(i);
      else if (SFT[i] == SPARROW) WriteSparrowFormat(i);
      else                        WriteBinaryFormat(i);
   }
}

// Assembly:
cmpl $0x0, 0x1a23b(%rip)     # 0x24d70
jle 0xab80
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7a8ce(%rip), %r14     # 0x85410
xorl %ebx, %ebx
movl (%r14), %eax
movl %ebx, %edi
cmpl $0x2, %eax
je 0xab5a
cmpl $0x1, %eax
jne 0xab61
callq 0xa925
jmp 0xab66
callq 0xa720
jmp 0xab66
callq 0xa5c0
incq %rbx
movslq 0x1a200(%rip), %rax     # 0x24d70
addq $0x4, %r14
cmpq %rax, %rbx
jl 0xab44
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: usage
void usage(void)
{
   printf("Usage: bs9 [options] <source>\n");
   printf("Options:\n");
   printf("   -d print details in file <Debug.lst>\n");
   printf("   -D Define symbols\n");
   printf("   -i ignore case in symbols\n");
   printf("   -I include path\n");
   printf("   -h display this usage\n");
   printf("   -l preset value for memory\n");
   printf("   -m Motorola codestyle: blank = field separator\n");
   printf("   -n include line numbers in listing\n");
   printf("   -o optimize long branches and jumps\n");
   printf("   -p print preprocessed source\n");
   printf("   -q quiet mode\n");
   printf("   -x assemble listing file - skip hex in front\n");
   exit(1);
}

// Assembly:
pushq %rax
leaq 0x2f01(%rip), %rdi      # 0xdaa2
callq 0x20a0
leaq 0x2f13(%rip), %rdi      # 0xdac0
callq 0x20a0
leaq 0x2f10(%rip), %rdi      # 0xdac9
callq 0x20a0
leaq 0x2f2c(%rip), %rdi      # 0xdaf1
callq 0x20a0
leaq 0x2f35(%rip), %rdi      # 0xdb06
callq 0x20a0
leaq 0x2f46(%rip), %rdi      # 0xdb23
callq 0x20a0
leaq 0x2f4d(%rip), %rdi      # 0xdb36
callq 0x20a0
leaq 0x2f5a(%rip), %rdi      # 0xdb4f
callq 0x20a0
leaq 0x2f6c(%rip), %rdi      # 0xdb6d
callq 0x20a0
leaq 0x2f92(%rip), %rdi      # 0xdb9f
callq 0x20a0
leaq 0x2fac(%rip), %rdi      # 0xdbc5
callq 0x20a0
leaq 0x2fc7(%rip), %rdi      # 0xdbec
callq 0x20a0
leaq 0x2fdb(%rip), %rdi      # 0xdc0c
callq 0x20a0
leaq 0x2fe0(%rip), %rdi      # 0xdc1d
callq 0x20a0
movl $0x1, %edi
callq 0x22f0