LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rdi
movq %rsp, %rsi
callq 0x2aa0
movq %rax, 0x118(%rsp)
movl $0x0, 0x10c(%rsp)
movl 0x10c(%rsp), %eax
cmpl 0x23cfd(%rip), %eax     # 0x28a14
jge 0x4d98
movq %rsp, %rdi
movslq 0x10c(%rsp), %rcx
leaq 0x23cf5(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x3940
cmpl $0x0, %eax
jne 0x4d80
movslq 0x10c(%rsp), %rcx
leaq 0x23cd2(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq 0x110(%rsp), %rax
movl %ecx, (%rax)
movl 0x10c(%rsp), %edi
callq 0x4bc0
movq 0x118(%rsp), %rax
movq %rax, 0x120(%rsp)
jmp 0x4dbe
jmp 0x4d82
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
jmp 0x4d0a
movq %rsp, %rdi
callq 0x4dd0
movq 0x110(%rsp), %rax
movl $0xff0000, (%rax)       # imm = 0xFF0000
movq 0x118(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rdi
movq %rsp, %rsi
callq 0x2aa0
movq %rax, 0x118(%rsp)
movl $0x0, 0x10c(%rsp)
movl 0x10c(%rsp), %eax
cmpl 0x239fd(%rip), %eax     # 0x28a14
jge 0x5098
movq %rsp, %rdi
movslq 0x10c(%rsp), %rcx
leaq 0x239f5(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x3940
cmpl $0x0, %eax
jne 0x5080
movslq 0x10c(%rsp), %rcx
leaq 0x239d2(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movq 0x110(%rsp), %rax
movl %ecx, (%rax)
movl 0x10c(%rsp), %edi
callq 0x4bc0
movq 0x118(%rsp), %rax
movq %rax, 0x120(%rsp)
jmp 0x50be
jmp 0x5082
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
jmp 0x500a
movq %rsp, %rdi
callq 0x4dd0
movq 0x110(%rsp), %rax
movl $0xff0000, (%rax)       # imm = 0xFF0000
movq 0x118(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: Nib2Byte
int Nib2Byte(char nib)
{
   if (nib >= '0' && nib <= '9') return nib - '0';
   if (nib >= 'A' && nib <= 'F') return nib - 'A' + 10;
   if (nib >= 'a' && nib <= 'f') return nib - 'a' + 10;
   return -1;
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
cmpl $0x30, %eax
jl 0x50f9
movsbl -0x5(%rsp), %eax
cmpl $0x39, %eax
jg 0x50f9
movsbl -0x5(%rsp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rsp)
jmp 0x514b
movsbl -0x5(%rsp), %eax
cmpl $0x41, %eax
jl 0x511e
movsbl -0x5(%rsp), %eax
cmpl $0x46, %eax
jg 0x511e
movsbl -0x5(%rsp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rsp)
jmp 0x514b
movsbl -0x5(%rsp), %eax
cmpl $0x61, %eax
jl 0x5143
movsbl -0x5(%rsp), %eax
cmpl $0x66, %eax
jg 0x5143
movsbl -0x5(%rsp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rsp)
jmp 0x514b
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %edi
callq 0x50d0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %edi
callq 0x50d0
movl %eax, (%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x5198
cmpl $0x0, (%rsp)
jl 0x5198
movl 0x4(%rsp), %eax
shll $0x4, %eax
orl (%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x51a0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x5, 0xc(%rsp)
jge 0x56c5
callq 0x22e0
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x56b6
jmp 0x56c5
jmp 0x56b8
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5686
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x48, %eax
je 0x56eb
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x68, %eax
jne 0x5712
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x5620
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x57f8
movq 0x18(%rsp), %rdi
callq 0x2290
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
callq 0x22e0
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x5756
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x5725
callq 0x22e0
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x5783
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x57f8
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x579d
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
jle 0x57b7
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x57c7
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jg 0x57c7
leaq 0xabe1(%rip), %rdi      # 0x1039f
movb $0x0, %al
callq 0x3150
jmp 0x57d5
leaq 0xac06(%rip), %rdi      # 0x103d4
movb $0x0, %al
callq 0x3150
movl 0x23231(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x23228(%rip)     # 0x28a0c
movq 0x18(%rsp), %rdi
callq 0x3040
movl $0x1, %edi
callq 0x22b0
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x5865
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x27, %eax
jne 0x5865
movq 0x10(%rsp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x27, %eax
je 0x5865
movq 0x8(%rsp), %rax
movl $0x5c, (%rax)
movq 0x10(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
jmp 0x5954
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x5937
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x589e
movq 0x8(%rsp), %rax
movl $0xd, (%rax)
jmp 0x591d
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x58b8
movq 0x8(%rsp), %rax
movl $0xa, (%rax)
jmp 0x591b
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x58d2
movq 0x8(%rsp), %rax
movl $0x7, (%rax)
jmp 0x5919
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
jne 0x58ec
movq 0x8(%rsp), %rax
movl $0x1b, (%rax)
jmp 0x5917
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x5906
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x5915
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5917
jmp 0x5919
jmp 0x591b
jmp 0x591d
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x5935
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x5952
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movsbl (%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5954
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x5995
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5995
movl 0x23098(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x2308f(%rip)     # 0x28a0c
leaq 0xaa77(%rip), %rdi      # 0x103fb
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x59ad
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x5a2b
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x59f7
jmp 0x5a2b
movq 0x8(%rsp), %rax
movl (%rax), %ecx
shll $0x8, %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movsbl (%rax), %eax
orl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x59e1
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x5a48
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x5a56
leaq 0xa9d9(%rip), %rdi      # 0x10428
movb $0x0, %al
callq 0x3150
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x15(%rsp)
je 0x5ad0
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x31, %ecx
movb %al, -0x15(%rsp)
je 0x5ad0
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0x15(%rsp)
je 0x5ad0
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0x15(%rsp)
je 0x5ad0
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
sete %al
movb %al, -0x15(%rsp)
movb -0x15(%rsp), %al
testb $0x1, %al
jne 0x5ada
jmp 0x5b38
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
je 0x5af4
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x5b01
movl -0x14(%rsp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x5b1b
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5b25
movl -0x14(%rsp), %eax
shll %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x5a72
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %edx
movl $0x29, %eax
movl $0x5d, %ecx
cmpl $0x5b, %edx
cmovel %ecx, %eax
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x4740
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movsbl 0x7(%rsp), %esi
callq 0x36a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5c37
movq 0x10(%rsp), %rdi
callq 0x3040
movsbl 0x7(%rsp), %esi
leaq 0xa82c(%rip), %rdi      # 0x10452
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movq 0x10(%rsp), %rax
addq $0x1, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3b70
movq %rax, 0x18(%rsp)
movsbl 0x21db7(%rip), %eax     # 0x27f80
cmpl $0x0, %eax
jne 0x61f0
movq 0x18(%rsp), %rdi
callq 0x3040
leaq 0xa32a(%rip), %rdi      # 0x10509
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movq 0x10(%rsp), %rsi
leaq 0x21d84(%rip), %rdi     # 0x27f80
xorl %edx, %edx
callq 0x4740
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x621f
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x626e
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0x624c
movq (%rsp), %rdi
callq 0x3040
leaq 0xa2f7(%rip), %rdi      # 0x10532
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movq (%rsp), %rdi
addq $0x1, %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x4740
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x20f0
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x815cc(%rip)     # 0x88150
jne 0x6b95
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x6c41
cmpl $0x0, 0xe5fc(%rip)      # 0x15198
je 0x6c37
cmpl $0x0, 0x21e4f(%rip)     # 0x289f8
jne 0x6c37
movl 0x8159b(%rip), %edi     # 0x88150
callq 0x3a60
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x6c22
movq 0x21e1c(%rip), %rdi     # 0x289e8
leaq 0x9a4b(%rip), %rsi      # 0x1061e
leaq 0x212a6(%rip), %rdx     # 0x27e80
movb $0x0, %al
callq 0x21e0
movq 0x21e00(%rip), %rdi     # 0x289e8
movl 0x10b26(%rip), %edx     # 0x17714
subl 0x8155c(%rip), %edx     # 0x88150
movslq 0x4(%rsp), %rcx
leaq 0x21e20(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
leaq 0x9a1e(%rip), %rsi      # 0x1062f
movb $0x0, %al
callq 0x21e0
movl $0x0, 0x8152e(%rip)     # 0x88150
movq 0x21dbf(%rip), %rdi     # 0x289e8
leaq 0xb0a1(%rip), %rsi      # 0x11cd1
movb $0x0, %al
callq 0x21e0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ParseBSSData
char *ParseBSSData(char *p)
{
   int m;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x38a0
movq %rax, 0x10(%rsp)
cmpl $0x1, 0xc(%rsp)
jl 0x766e
cmpl $0x7fff, 0xc(%rsp)      # imm = 0x7FFF
jle 0x768a
movl 0xc(%rsp), %esi
leaq 0x920e(%rip), %rdi      # 0x10887
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
cmpl $0x0, 0xdb07(%rip)      # 0x15198
je 0x76be
cmpl $0x0, 0x2135e(%rip)     # 0x289f8
jne 0x76be
movq 0x21345(%rip), %rdi     # 0x289e8
movl 0x21367(%rip), %edx     # 0x28a10
leaq 0x91ec(%rip), %rsi      # 0x1089c
leaq 0x207c9(%rip), %rcx     # 0x27e80
movb $0x0, %al
callq 0x21e0
movl 0xc(%rsp), %eax
addl 0x21348(%rip), %eax     # 0x28a10
movl %eax, 0x21342(%rip)     # 0x28a10
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ParseCPUData
char *ParseCPUData(char *p)
{
   p = SkipSpace(p);
   if (*p == '=') ++p;
   p = EvalOperand(p,&CPU,0);
   if (CPU == 6809)
   {
      DimOp = DIMOP_6809;
      RegisterNames = Register_6809;
   }
   else if (CPU == 6309)
   {
      DimOp = DIMOP_6309;
      RegisterNames = Register_6309;
   }
   else
   {
      ErrorMsg("Unknown CPU %d - use 6809 or 6309\n",CPU);
      exit(1);
   }
   if (ListOn && !Pass)
   {
      PrintLiNo();
      fprintf(lf,"%4d              %s\n",CPU,Line);
   }
   return p;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x2830
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x770a
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0xda7b(%rip), %rsi      # 0x15190
xorl %edx, %edx
callq 0x4740
movq %rax, (%rsp)
cmpl $0x1a99, 0xda66(%rip)   # imm = 0x1A99
jne 0x7746
movl $0x8b, 0xfe5a(%rip)     # 0x17590
leaq 0xfee3(%rip), %rax      # 0x17620
movq %rax, 0xff5c(%rip)      # 0x176a0
jmp 0x778c
cmpl $0x18a5, 0xda40(%rip)   # imm = 0x18A5
jne 0x776c
movl $0xe6, 0xfe34(%rip)     # 0x17590
leaq 0xfe3d(%rip), %rax      # 0x175a0
movq %rax, 0xff36(%rip)      # 0x176a0
jmp 0x778a
movl 0xda1e(%rip), %esi      # 0x15190
leaq 0x9139(%rip), %rdi      # 0x108b2
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
jmp 0x778c
cmpl $0x0, 0xda05(%rip)      # 0x15198
je 0x77c5
cmpl $0x0, 0x2125c(%rip)     # 0x289f8
jne 0x77c5
callq 0x3320
movq 0x2123e(%rip), %rdi     # 0x289e8
movl 0xd9e0(%rip), %edx      # 0x15190
leaq 0x911e(%rip), %rsi      # 0x108d5
leaq 0x206c2(%rip), %rcx     # 0x27e80
movb $0x0, %al
callq 0x21e0
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ParseOnOff
char *ParseOnOff(char *p, int *v)
{
   p = SkipSpace(p);
        if (*p == '1') *v = 1;
   else if (*p == '0') *v = 0;
   else if (!StrNCaseCmp(p,"ON" ,2)) *v = 1;
   else if (!StrNCaseCmp(p,"OFF",3)) *v = 0;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2830
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x780a
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
jmp 0x7892
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x7824
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x7890
movq 0x10(%rsp), %rdi
leaq 0x90ba(%rip), %rsi      # 0x108ea
movl $0x2, %edx
callq 0x2d70
cmpl $0x0, %eax
jne 0x784c
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
jmp 0x788e
movq 0x10(%rsp), %rdi
leaq 0x9095(%rip), %rsi      # 0x108ed
movl $0x3, %edx
callq 0x2d70
cmpl $0x0, %eax
jne 0x7874
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x788c
leaq 0x9076(%rip), %rdi      # 0x108f1
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
jmp 0x788e
jmp 0x7890
jmp 0x7892
cmpl $0x0, 0xd8ff(%rip)      # 0x15198
je 0x78c5
cmpl $0x0, 0x21156(%rip)     # 0x289f8
jne 0x78c5
callq 0x3320
movq 0x21138(%rip), %rdi     # 0x289e8
leaq 0x88c3(%rip), %rsi      # 0x1017a
leaq 0x205c2(%rip), %rdx     # 0x27e80
movb $0x0, %al
callq 0x21e0
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x20f0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ParseBitData
char *ParseBitData(char *p)
{
   int i,v;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x797d
movl 0x8(%rsp), %eax
shll %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
callq 0x2830
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x7947
movl 0x8(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x796e
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x796c
leaq 0x8fa6(%rip), %rdi      # 0x10901
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
jmp 0x796e
jmp 0x7970
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7909
cmpl $0x0, 0xd814(%rip)      # 0x15198
je 0x79d8
cmpl $0x0, 0x2106b(%rip)     # 0x289f8
jne 0x79d8
callq 0x3350
movl 0xfd7a(%rip), %edi      # 0x17714
movl 0x8(%rsp), %esi
callq 0x23f0
movq 0x2103e(%rip), %rdi     # 0x289e8
movl 0x8(%rsp), %edx
leaq 0x8f80(%rip), %rsi      # 0x10935
movb $0x0, %al
callq 0x21e0
movq 0x21025(%rip), %rdi     # 0x289e8
leaq 0x87c2(%rip), %rsi      # 0x1018c
leaq 0x204af(%rip), %rdx     # 0x27e80
movb $0x0, %al
callq 0x21e0
movl 0xfd36(%rip), %eax      # 0x17714
addl $0x1, %eax
movl %eax, 0xfd2d(%rip)      # 0x17714
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x20f0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ParseCmapData
char *ParseCmapData(char *p)
{
   int i,v,scanline;

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

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x7a4c
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x38, %eax
jge 0x7a4c
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, 0x14(%rsp)
jmp 0x7a54
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x1c(%rsp)
cmpl $0x8, 0x1c(%rsp)
jge 0x7ad0
movl 0x18(%rsp), %eax
shll %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
callq 0x2830
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x7a9a
movl 0x18(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x7ac1
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x7abf
leaq 0x8e99(%rip), %rdi      # 0x10947
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
jmp 0x7ac1
jmp 0x7ac3
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x7a5c
cmpl $0x0, 0x20f21(%rip)     # 0x289f8
jne 0x7b5d
cmpl $0x0, 0xd6b4(%rip)      # 0x15198
je 0x7aeb
callq 0x3350
cmpl $0x0, 0x14(%rsp)
jge 0x7b03
movl 0xfc1c(%rip), %edi      # 0x17714
movl 0x18(%rsp), %esi
callq 0x23f0
jmp 0x7b1d
movl 0xfc0b(%rip), %edi      # 0x17714
movl 0x14(%rsp), %eax
shll %eax
addl %eax, %edi
subl $0x7, %edi
movl 0x18(%rsp), %esi
callq 0x23f0
cmpl $0x0, 0xd674(%rip)      # 0x15198
je 0x7b5b
movq 0x20ebb(%rip), %rdi     # 0x289e8
movl 0x18(%rsp), %edx
leaq 0x8e43(%rip), %rsi      # 0x1097b
movb $0x0, %al
callq 0x21e0
movq 0x20ea2(%rip), %rdi     # 0x289e8
leaq 0x863f(%rip), %rsi      # 0x1018c
leaq 0x2032c(%rip), %rdx     # 0x27e80
movb $0x0, %al
callq 0x21e0
jmp 0x7b5d
movl 0xfbb1(%rip), %eax      # 0x17714
addl $0x1, %eax
movl %eax, 0xfba8(%rip)      # 0x17714
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x2830
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0x7fb53(%rip), %rsi     # 0x88150
movl $0x4d, %edx
callq 0x3de0
leaq 0x1f772(%rip), %rdi     # 0x27d80
leaq 0x7f92b(%rip), %rsi     # 0x87f40
callq 0x2070
cmpl $0x0, 0x203d7(%rip)     # 0x289f8
jne 0x8648
cmpl $0x0, 0xcb6e(%rip)      # 0x15198
je 0x8648
movq 0x203b5(%rip), %rdi     # 0x289e8
leaq 0x7b44(%rip), %rsi      # 0x1017e
leaq 0x1f83f(%rip), %rdx     # 0x27e80
movb $0x0, %al
callq 0x21e0
movq (%rsp), %rax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpl $0x0, 0x2039c(%rip)     # 0x289f8
jne 0x8679
cmpl $0x0, 0xcb33(%rip)      # 0x15198
je 0x8679
callq 0x3350
movq (%rsp), %rdi
callq 0x6b60
movq %rax, (%rsp)
movb $0x0, 0x1f700(%rip)     # 0x27d80
movl $0x0, 0x7fac6(%rip)     # 0x88150
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2830
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x896b
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x898e
movl $0x1, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x89a1
movl 0x7fafd(%rip), %eax     # 0x88498
movl %eax, 0x14(%rsp)
jmp 0x89a9
movl $0x12, 0x14(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x61a0
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x8a62
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x20035(%rip), %eax     # 0x28a10
cltd
idivl 0x1c(%rsp)
movl 0x10(%rsp), %eax
subl %edx, %eax
cltd
idivl 0x1c(%rsp)
movl %edx, 0x1c(%rsp)
cmpq $0x0, 0x1fff9(%rip)     # 0x289f0
je 0x8a23
movq 0x1fff0(%rip), %rdi     # 0x289f0
movl 0x2000a(%rip), %edx     # 0x28a10
movl 0x20004(%rip), %ecx     # 0x28a10
addl 0x1c(%rsp), %ecx
movl 0x14(%rsp), %r8d
leaq 0x8013(%rip), %rsi      # 0x10a2f
movb $0x0, %al
callq 0x21e0
jmp 0x8a25
movl 0x1c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rsp)
cmpl $0x0, %eax
je 0x8a5d
movl 0x14(%rsp), %eax
movb %al, %dl
movl 0x1ffcd(%rip), %eax     # 0x28a10
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1ffc2(%rip)     # 0x28a10
movslq %eax, %rcx
leaq 0xf1d8(%rip), %rax      # 0x17c30
movb %dl, (%rax,%rcx)
jmp 0x8a25
jmp 0x8af4
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xeca4(%rip), %eax      # 0x17714
cltd
idivl 0x1c(%rsp)
movl 0xc(%rsp), %eax
subl %edx, %eax
cltd
idivl 0x1c(%rsp)
movl %edx, 0x1c(%rsp)
cmpq $0x0, 0x1ff64(%rip)     # 0x289f0
je 0x8ab8
movq 0x1ff5b(%rip), %rdi     # 0x289f0
movl 0xec79(%rip), %edx      # 0x17714
movl 0xec73(%rip), %ecx      # 0x17714
addl 0x1c(%rsp), %ecx
movl 0x14(%rsp), %r8d
leaq 0x7fa3(%rip), %rsi      # 0x10a54
movb $0x0, %al
callq 0x21e0
jmp 0x8aba
movl 0x1c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rsp)
cmpl $0x0, %eax
je 0x8af2
movl 0x14(%rsp), %eax
movb %al, %dl
movl 0xec3c(%rip), %eax      # 0x17714
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xec31(%rip)      # 0x17714
movslq %eax, %rcx
leaq 0xf143(%rip), %rax      # 0x17c30
movb %dl, (%rax,%rcx)
jmp 0x8aba
jmp 0x8af4
callq 0x3500
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: SetPC
char *SetPC(char *p)
{
   p = NeedChar(p,'=');
   if (p) return ps_org(p+1);

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

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x3d, %esi
callq 0x36a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x8b6d
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x8b10
popq %rcx
retq
movl 0x1fe99(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x1fe90(%rip)     # 0x28a0c
leaq 0x7ef6(%rip), %rdi      # 0x10a79
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x38a0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x8be0
movl 0xc(%rsp), %esi
leaq 0x7ed6(%rip), %rdi      # 0x10aa5
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
callq 0x3500
movl 0xc(%rsp), %eax
addl 0xeb25(%rip), %eax      # 0x17714
movl %eax, 0xeb1f(%rip)      # 0x17714
movq 0x10(%rsp), %rdi
callq 0x20f0
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x7ec9(%rip), %rsi      # 0x10afe
callq 0x2880
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x8c63
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
leaq 0xeabd(%rip), %rsi      # 0x17714
xorl %edx, %edx
callq 0x4740
movq %rax, 0x8(%rsp)
callq 0x3500
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x7f80c(%rip), %rsi     # 0x8849c
callq 0x38a0
movq %rax, (%rsp)
cmpl $0xff, 0x7f7f9(%rip)    # 0x8849c
jle 0x8cb4
movl 0x7f7f1(%rip), %eax     # 0x8849c
sarl $0x8, %eax
movl %eax, 0x7f7e8(%rip)     # 0x8849c
movl 0x7f7e2(%rip), %edi     # 0x8849c
callq 0x3540
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2830
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x22, 0x14(%rsp)
jge 0x8dc5
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rcx
leaq 0xece4(%rip), %rax      # 0x179f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x2e80
cmpl $0x0, %eax
jne 0x8db3
movslq 0x14(%rsp), %rcx
leaq 0xecc0(%rip), %rax      # 0x179f0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movslq 0x14(%rsp), %rcx
leaq 0xec9b(%rip), %rax      # 0x179f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x20f0
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rdi
callq *%rax
movq %rax, 0x18(%rsp)
cmpl $0x10000, 0xe990(%rip)  # imm = 0x10000
jle 0x8da8
leaq 0x7e2a(%rip), %rdi      # 0x10bb7
movb $0x0, %al
callq 0x3150
movq 0x18(%rsp), %rdi
callq 0x3040
movl $0x1, %edi
callq 0x22b0
movq $0x0, 0x20(%rsp)
jmp 0x8dcf
jmp 0x8db5
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8cf0
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movslq 0x10(%rsp), %rax
leaq 0xbedc(%rip), %rdi      # 0x151a0
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq 0x7a29(%rip), %rsi      # 0x10cfb
movl $0x4, %edx
callq 0x2d70
cmpl $0x0, %eax
jne 0x92ee
movl $0x1, 0x14(%rsp)
jmp 0x9425
movslq 0x10(%rsp), %rax
leaq 0xbea6(%rip), %rdi      # 0x151a0
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq 0x79f8(%rip), %rsi      # 0x10d00
movl $0x4, %edx
callq 0x2d70
cmpl $0x0, %eax
jne 0x9324
movl $0x1, 0x14(%rsp)
jmp 0x9425
movslq 0x10(%rsp), %rcx
leaq 0xbe70(%rip), %rax      # 0x151a0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movslq 0x10(%rsp), %rax
leaq 0xbe59(%rip), %rdi      # 0x151a0
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x20f0
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x41, %eax
je 0x9397
movsbl 0xf(%rsp), %eax
cmpl $0x42, %eax
je 0x9397
movsbl 0xf(%rsp), %eax
cmpl $0x43, %eax
je 0x9397
movsbl 0xf(%rsp), %eax
cmpl $0x45, %eax
je 0x9397
movsbl 0xf(%rsp), %eax
cmpl $0x46, %eax
jne 0x93a4
movl $0x1, 0x14(%rsp)
jmp 0x9425
movsbl 0xf(%rsp), %eax
cmpl $0x44, %eax
je 0x93cc
movsbl 0xf(%rsp), %eax
cmpl $0x58, %eax
je 0x93cc
movsbl 0xf(%rsp), %eax
cmpl $0x59, %eax
je 0x93cc
movsbl 0xf(%rsp), %eax
cmpl $0x57, %eax
jne 0x93d6
movl $0x2, 0x14(%rsp)
jmp 0x9425
movsbl 0xf(%rsp), %eax
cmpl $0x53, %eax
je 0x93ea
movsbl 0xf(%rsp), %eax
cmpl $0x55, %eax
jne 0x93f4
movl $0x2, 0x14(%rsp)
jmp 0x9425
movsbl 0xf(%rsp), %eax
cmpl $0x51, %eax
jne 0x9408
movl $0x4, 0x14(%rsp)
jmp 0x9425
movsbl 0xf(%rsp), %esi
leaq 0x78f1(%rip), %rdi      # 0x10d05
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xf, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0x94a8
movq 0xe24c(%rip), %rax      # 0x176a0
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xe22d(%rip), %rax      # 0x176a0
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0x2d70
cmpl $0x0, %eax
jne 0x9499
jmp 0x94a8
jmp 0x949b
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9446
cmpl $0x0, 0x24(%rsp)
jge 0x94d1
movq 0x30(%rsp), %rdi
callq 0x3040
leaq 0x7861(%rip), %rdi      # 0x10d21
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0xe1b4(%rip), %rax      # 0x176a0
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20f0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2830
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x9533
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x4, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x959a
movq 0xe13c(%rip), %rax      # 0x176a0
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x2080
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jne 0x958b
jmp 0x959a
jmp 0x958d
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x9556
cmpl $0x0, 0x4(%rsp)
jge 0x95c3
movq 0x10(%rsp), %rdi
callq 0x3040
leaq 0x7797(%rip), %rdi      # 0x10d49
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, (%rsp)
movl 0x1f421(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x1f418(%rip)     # 0x28a0c
movq (%rsp), %rdi
callq 0x3040
leaq 0x7775(%rip), %rdi      # 0x10d79
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
addl $-0x53, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x26, %eax
ja 0x96cf
movq (%rsp), %rax
leaq 0x69ce(%rip), %rcx      # 0x10020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x14(%rsp)
jge 0x966c
movl $0x0, 0x14(%rsp)
jmp 0x9676
movq 0x8(%rsp), %rdi
callq 0x95e0
jmp 0x96d9
cmpl $0x0, 0x14(%rsp)
jge 0x9689
movl $0x20, 0x14(%rsp)
jmp 0x9693
movq 0x8(%rsp), %rdi
callq 0x95e0
jmp 0x96d9
cmpl $0x0, 0x14(%rsp)
jge 0x96a6
movl $0x40, 0x14(%rsp)
jmp 0x96b0
movq 0x8(%rsp), %rdi
callq 0x95e0
jmp 0x96d9
cmpl $0x0, 0x14(%rsp)
jge 0x96c3
movl $0x60, 0x14(%rsp)
jmp 0x96cd
movq 0x8(%rsp), %rdi
callq 0x95e0
jmp 0x96d9
movq 0x8(%rsp), %rdi
callq 0x95e0
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x6e18(%rip), %rsi      # 0x10e7d
callq 0x2e80
cmpl $0x0, %eax
jne 0xa07c
movl $0xff, 0x24(%rsp)
jmp 0xa1ac
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0xa1a4
movl $0x9, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0xa111
movslq 0x14(%rsp), %rcx
leaq 0xd603(%rip), %rax      # 0x176b0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x20f0
movl %eax, 0x10(%rsp)
cmpq $0x0, 0x1e923(%rip)     # 0x289f0
je 0xa0ed
movq 0x1e91a(%rip), %rdi     # 0x289f0
movq 0x18(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x6d9b(%rip), %rsi      # 0x10e81
movb $0x0, %al
callq 0x21e0
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2e80
cmpl $0x0, %eax
jne 0xa102
jmp 0xa111
jmp 0xa104
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa09a
cmpl $0x0, 0x14(%rsp)
jge 0xa122
movq 0x18(%rsp), %rdi
callq 0x95e0
movslq 0x14(%rsp), %rcx
leaq 0xd582(%rip), %rax      # 0x176b0
movl 0x4(%rax,%rcx,8), %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x10(%rsp), %rax
addq %rax, %rdi
callq 0x2830
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0xa175
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa175
movq 0x18(%rsp), %rdi
callq 0x95e0
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xa190
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2830
movq %rax, 0x18(%rsp)
jmp 0xa084
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movl $0x0, 0x118(%rsp)
movq 0x120(%rsp), %rax
movl $0x0, (%rax)
movq 0x130(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0xbedd
cmpl $0xa, 0x118(%rsp)
setl %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xbeea
jmp 0xc027
movq 0x130(%rsp), %rdi
callq 0x2830
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0xbf14
jmp 0xc027
movq 0x130(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2c30
movq %rax, 0x130(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x20f0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbf81
movq 0x128(%rsp), %rdi
movq 0x120(%rsp), %rax
movslq 0x118(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
addq %rax, %rdi
leaq 0x10(%rsp), %rsi
movl 0x11c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x2260
jmp 0xbfa1
movq 0x128(%rsp), %rax
movq 0x120(%rsp), %rcx
movslq 0x118(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movb $0x0, (%rax,%rcx)
movl 0x118(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x118(%rsp)
movq 0x120(%rsp), %rax
movl 0x118(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl 0x11c(%rsp), %edx
addl $0x1, %edx
movq 0x120(%rsp), %rax
movslq 0x118(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x130(%rsp), %rdi
callq 0x2830
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0xc00e
jmp 0xc027
movq 0x130(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x130(%rsp)
jmp 0xbeb8
movl 0x118(%rsp), %eax
addq $0x138, %rsp            # imm = 0x138
retq
nopw %cs:(%rax,%rax)