LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
leaq 0x5845(%rip), %rsi      # 0xcf91
callq 0x2cc9
testl %eax, %eax
je 0x784f
cmpb $0x0, (%rbx)
je 0x7856
leaq 0x582c(%rip), %r14      # 0xcf95
xorl %ebp, %ebp
movl $0xa, %r13d
leaq 0xcfa0(%rip), %r12      # 0x14718
movq %r12, %rdi
callq 0x2110
movq %rax, %r15
movq 0x1e286(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x779f
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2cc9
testl %eax, %eax
je 0x77bf
addq $-0x8, %r12
decq %r13
jne 0x7778
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x77c2
decl %r13d
testl %r13d, %r13d
js 0x7869
movl %r13d, %eax
leaq 0xcefb(%rip), %rcx      # 0x146d0
orl 0x4(%rcx,%rax,8), %ebp
movslq %r15d, %r15
cmpb $0x0, (%rbx,%r15)
je 0x7802
callq 0x2320
movq (%rax), %rax
addq %r15, %rbx
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x77f1
jmp 0x7805
addq %r15, %rbx
movzbl (%rbx), %eax
testl %eax, %eax
je 0x7811
cmpl $0x2c, %eax
jne 0x7869
xorl %r15d, %r15d
cmpb $0x2c, (%rbx)
sete %r15b
cmpb $0x0, (%rbx,%r15)
je 0x7841
callq 0x2320
movq (%rax), %rax
addq %r15, %rbx
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7830
jmp 0x7844
addq %r15, %rbx
cmpb $0x0, (%rbx)
jne 0x776b
jmp 0x7858
movl $0xff, %ebp
jmp 0x7858
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x6fe1
// File: /workspace/github_c_makefile_star2_O1/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, %rbp
movq 0x1cfd5(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x8a53
leaq 0x495d(%rip), %rsi      # 0xd3a4
movl %ebx, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x2210
movl $0x0, (%r14)
xorl %r12d, %r12d
testl %ebx, %ebx
jle 0x8b81
cmpb $0x0, (%rbp)
je 0x8b81
leal -0x1(%rbx), %eax
cltq
movq %rax, 0x8(%rsp)
movl %ebx, %eax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0x1cf81(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x8aa8
leaq 0x491c(%rip), %rsi      # 0xd3b7
movl %r12d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x2210
cmpb $0x0, (%rbp)
je 0x8ac8
callq 0x2320
movq (%rax), %rax
decq %rbp
movsbq 0x1(%rbp), %rcx
incq %rbp
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8ab9
cmpb $0x29, (%rbp)
je 0x8b81
movq %rbp, %rdi
movq %r13, %rsi
cmpl $0xa, %ebx
jne 0x8ae4
callq 0x2aa4
jmp 0x8ae9
callq 0x2b4e
movq %rax, %r15
movq %r13, %rdi
callq 0x2110
movq %rax, %rbp
movslq (%r14,%r12,4), %rdi
addq 0x18(%rsp), %rdi
testl %ebp, %ebp
je 0x8b15
movl %ebp, %eax
incl %eax
movslq %eax, %rdx
movq %r13, %rsi
callq 0x2250
jmp 0x8b18
movb $0x0, (%rdi)
movl (%r14,%r12,4), %eax
addl %ebp, %eax
incl %eax
movl %eax, 0x4(%r14,%r12,4)
cmpb $0x0, (%r15)
je 0x8b45
callq 0x2320
movq (%rax), %rax
decq %r15
movsbq 0x1(%r15), %rcx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8b36
incq %r12
movzbl (%r15), %eax
cmpl $0x2c, %eax
je 0x8b62
cmpl $0x29, %eax
je 0x8b81
cmpl $0x9, %ebx
jg 0x8b62
cmpq 0x8(%rsp), %r12
jl 0x8b96
xorl %ecx, %ecx
cmpb $0x2c, %al
sete %al
cmpq 0x10(%rsp), %r12
jae 0x8b81
movb %al, %cl
leaq (%r15,%rcx), %rbp
cmpb $0x0, (%r15,%rcx)
jne 0x8a88
movl %r12d, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl 0x1ce90(%rip)           # 0x25a2c
movsbl (%r15), %esi
leaq 0x481e(%rip), %rdi      # 0xd3c5
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x8ca7
movq %rdx, %rbx
movq %rdi, %rbp
xorl %r14d, %r14d
callq 0x2320
movq %rax, (%rsp)
leaq 0x10(%rsp), %r12
movq %r14, %r15
movq (%rsp), %rax
movq (%rax), %rax
decq %rbp
movsbq 0x1(%rbp), %rcx
incq %rbp
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8c01
cmpb $0x3b, (%rbp)
je 0x8cac
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2baa
movq %rax, %r13
movq %r12, %rdi
callq 0x2110
movq %rax, %r14
movslq (%rbx,%r15,4), %rdi
addq 0x8(%rsp), %rdi
testl %r14d, %r14d
je 0x8c53
movl %r14d, %eax
incl %eax
movslq %eax, %rdx
movq %r12, %rsi
callq 0x2250
jmp 0x8c56
movb $0x0, (%rdi)
movl (%rbx,%r15,4), %eax
addl %r14d, %eax
incl %eax
movl %eax, 0x4(%rbx,%r15,4)
cmpb $0x0, (%r13)
je 0x8c85
callq 0x2320
movq (%rax), %rax
decq %r13
movsbq 0x1(%r13), %rcx
incq %r13
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x8c76
leaq 0x1(%r15), %r14
cmpb $0x2c, (%r13)
jne 0x8caf
cmpq $0x8, %r15
ja 0x8caf
leaq 0x1(%r13), %rbp
cmpb $0x0, 0x1(%r13)
jne 0x8bf4
jmp 0x8caf
xorl %r14d, %r14d
jmp 0x8caf
movq %r15, %r14
movl %r14d, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1cd3c(%rip), %rcx     # 0x25a10
leaq 0x4711(%rip), %rbx      # 0xd3ec
movl $0x12, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2300
movq 0x1cd1c(%rip), %rdi     # 0x25a10
movslq %ebp, %r14
shlq $0x5, %r14
leaq 0x7a94e(%rip), %r15     # 0x83650
movq (%r14,%r15), %rdx
leaq 0x46f2(%rip), %rsi      # 0xd3ff
xorl %eax, %eax
callq 0x2210
movq 0x1ccf5(%rip), %rdi     # 0x25a10
movl 0x10(%r14,%r15), %edx
leaq 0x46e2(%rip), %rsi      # 0xd409
xorl %eax, %eax
callq 0x2210
movq 0x1ccdb(%rip), %rdi     # 0x25a10
movl 0x14(%r14,%r15), %edx
leaq 0x46d2(%rip), %rsi      # 0xd413
xorl %eax, %eax
callq 0x2210
movq 0x1ccc1(%rip), %rdi     # 0x25a10
movl 0x18(%r14,%r15), %edx
leaq 0x46c2(%rip), %rsi      # 0xd41d
xorl %eax, %eax
callq 0x2210
movq 0x1cca7(%rip), %rdi     # 0x25a10
movq 0x8(%r14,%r15), %rdx
leaq 0x46b2(%rip), %rsi      # 0xd427
xorl %eax, %eax
callq 0x2210
movq 0x1cc8d(%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_O1/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 0x35ff
movl %eax, %ebx
testl %eax, %eax
js 0x949f
movq 0x1c68d(%rip), %rdi     # 0x25a10
movl %ebx, %r12d
testq %rdi, %rdi
je 0x93b1
movq %r12, %rax
shlq $0x5, %rax
leaq 0x7a2b7(%rip), %rcx     # 0x83650
movq (%rax,%rcx), %rdx
movl 0x1c675(%rip), %ecx     # 0x25a18
leaq 0x412b(%rip), %rsi      # 0xd4d5
xorl %eax, %eax
callq 0x2210
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2baa
movq %rax, %r15
cmpb $0x0, (%rax)
je 0x93de
callq 0x2320
movq (%rax), %rax
decq %r15
movsbq 0x1(%r15), %rcx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x93cf
xorl %edi, %edi
cmpb $0x28, (%r15)
sete %dil
addq %r15, %rdi
callq 0x369b
shlq $0x5, %r12
leaq 0x7a255(%rip), %r15     # 0x83650
movl 0x10(%r12,%r15), %ecx
leaq 0x1bb99(%rip), %rdi     # 0x24fa0
leaq 0x7e3d2(%rip), %rsi     # 0x877e0
leaq 0x7e4cb(%rip), %rdx     # 0x878e0
callq 0x8a16
movl 0x10(%r12,%r15), %ecx
cmpl %ecx, %eax
jne 0x94b0
addq %r12, %r15
movslq 0x7e4d7(%rip), %rax     # 0x87908
leaq 0x1(%rax), %rdx
movl %edx, 0x7e4cd(%rip)     # 0x87908
movq 0x8(%r15), %rcx
leaq 0x7e4ca(%rip), %rsi     # 0x87910
movq %rcx, 0x8(%rsi,%rax,8)
movq 0x1c5be(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x9465
leaq 0x40c8(%rip), %rsi      # 0xd526
xorl %eax, %eax
callq 0x2210
movq 0x1c5a4(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x9483
movq 0x8(%r15), %rdx
leaq 0x40ba(%rip), %rsi      # 0xd536
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x1c58e(%rip)     # 0x25a18
jne 0x949f
leaq 0x1ba0d(%rip), %rax     # 0x24ea0
subl %eax, %r14d
movl %r14d, 0x14(%r15)
callq 0x313c
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
incl 0x1c576(%rip)           # 0x25a2c
leaq 0x4032(%rip), %rdi      # 0xd4ef
movq %rsp, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2e63
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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 0x1c52f(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x94f7
leaq 0x405f(%rip), %rsi      # 0xd54c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2210
decl 0x1b85b(%rip)           # 0x24d58
movl 0x7e405(%rip), %eax     # 0x87908
leaq 0x7e406(%rip), %r14     # 0x87910
testl %eax, %eax
jle 0x952b
movl %eax, %ecx
movq (%r14,%rcx,8), %rcx
cmpb $0x0, (%rcx)
jne 0x952b
leal -0x1(%rax), %ecx
movl %ecx, 0x7e3e6(%rip)     # 0x87908
cmpl $0x1, %eax
movl %ecx, %eax
jg 0x950e
xorl %eax, %eax
movq 0x1c4de(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
je 0x954c
movslq %eax, %rdx
movq (%r14,%rdx,8), %rcx
leaq 0x401b(%rip), %rsi      # 0xd560
xorl %eax, %eax
callq 0x2210
movslq 0x7e3b5(%rip), %rax     # 0x87908
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0x95e4
cmpb $0x0, (%rax)
je 0x95e4
leaq 0x7e374(%rip), %rax     # 0x878e0
leaq 0x7e26d(%rip), %rcx     # 0x877e0
movslq 0x7e38e(%rip), %rsi     # 0x87908
movq (%r14,%rsi,8), %rdx
movzbl (%rdx), %edi
cmpl $0x60, %edi
je 0x95a0
testl %edi, %edi
je 0x95e4
cmpl $0xa, %edi
je 0x95dd
leaq 0x1(%rdx), %rdi
movq %rdi, (%r14,%rsi,8)
movb (%rdx), %dl
movb %dl, (%rbx)
incq %rbx
jmp 0x9573
leaq 0x1(%rdx), %rdi
movq %rdi, (%r14,%rsi,8)
movsbq 0x1(%rdx), %rdx
movslq -0xc0(%rax,%rdx,4), %rsi
movb (%rsi,%rcx), %dl
testb %dl, %dl
je 0x95d0
addq %rcx, %rsi
incq %rsi
movb %dl, (%rbx)
incq %rbx
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x95c2
movslq 0x7e331(%rip), %rdx     # 0x87908
incq (%r14,%rdx,8)
jmp 0x9573
incq %rdx
movq %rdx, (%r14,%rsi,8)
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1be2a(%rip), %rdi     # 0x25a10
movl 0x1b16c(%rip), %edx     # 0x24d58
movl 0xab42(%rip), %ecx      # 0x14734
leaq 0x39e2(%rip), %rsi      # 0xd5db
xorl %eax, %eax
callq 0x2210
cmpb $0x0, 0x7b359(%rip)     # 0x84f60
je 0x9c48
movq 0x1be00(%rip), %rbx     # 0x25a10
leaq 0x7b349(%rip), %r14     # 0x84f60
movq %r14, %rdi
callq 0x357d
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
leaq 0x1be10(%rip), %rcx     # 0x25a40
movl 0xc(%rax,%rcx), %ecx
leaq 0x39aa(%rip), %rsi      # 0xd5e5
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
cmpb $0x0, 0x7e301(%rip)     # 0x87f50
je 0x9c6d
movq 0x1bdb8(%rip), %rdi     # 0x25a10
leaq 0x2ae2(%rip), %rsi      # 0xc741
leaq 0x7e2ea(%rip), %rdx     # 0x87f50
xorl %eax, %eax
callq 0x2210
movq 0x1bd9c(%rip), %rsi     # 0x25a10
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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, 0x1b0cf(%rip)     # 0x24d5c
je 0x9caa
movq 0x1bd72(%rip), %rdi     # 0x25a08
movl 0x1b0bc(%rip), %edx     # 0x24d58
leaq 0x25db(%rip), %rsi      # 0xc27e
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x1bd67(%rip)     # 0x25a18
jne 0x9cfc
cmpl $0x0, 0x84fe(%rip)      # 0x121b8
je 0x9ce8
movq 0x1bd45(%rip), %rdi     # 0x25a08
movslq 0x1bd36(%rip), %rax     # 0x25a00
leaq (%rax,%rax,2), %rax
leaq 0x1b3cb(%rip), %rcx     # 0x250a0
movq 0x10(%rcx,%rax,8), %rdx
leaq 0x392b(%rip), %rsi      # 0xd60c
xorl %eax, %eax
callq 0x2210
movq 0x1bd19(%rip), %rdi     # 0x25a08
callq 0x20b0
testl %eax, %eax
jne 0x9d7e
movq 0x7b475(%rip), %rdi     # 0x85178
callq 0x2100
testl %eax, %eax
jne 0x9d79
movslq 0x1bced(%rip), %rax     # 0x25a00
leaq (%rax,%rax,2), %rax
leaq 0x1b382(%rip), %rbx     # 0x250a0
movq 0x10(%rbx,%rax,8), %rdi
callq 0x2040
movslq 0x1bcd1(%rip), %rax     # 0x25a00
decq %rax
movl %eax, 0x1bcc8(%rip)     # 0x25a00
leaq (%rax,%rax,2), %rax
movq (%rbx,%rax,8), %rdx
movq %rdx, 0x7b431(%rip)     # 0x85178
movl 0x8(%rbx,%rax,8), %eax
movl %eax, 0x1b007(%rip)     # 0x24d58
leaq 0x1b148(%rip), %rdi     # 0x24ea0
movl $0x100, %esi            # imm = 0x100
callq 0x21c0
movl $0x0, 0x7b744(%rip)     # 0x854b0
movq 0x7b405(%rip), %rdi     # 0x85178
popq %rbx
jmp 0x2230
callq 0x23d6
callq 0x23c1
// File: /workspace/github_c_makefile_star2_O1/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, 0x7f7a(%rip)      # 0x121b8
je 0xa3ec
testl %esi, %esi
jle 0xa3ec
cmpl $0x0, 0x1b7e1(%rip)     # 0x25a34
jle 0xa3ec
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r8d
movq %rdi, %r14
movl %esi, %edi
leaq 0x1b7ca(%rip), %r9      # 0x25a40
leaq 0x3455(%rip), %r13      # 0xd6d2
xorl %ebp, %ebp
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
leaq (,%rbp,2), %r15
addq %rbp, %r15
shlq $0x4, %r15
movl 0xc(%r15,%r9), %ecx
cmpl %edx, %ecx
setl %al
cmpl %r8d, %ecx
setg %sil
orb %al, %sil
jne 0xa3c6
addq %r9, %r15
movq (%r15), %rdx
movq %r14, %rdi
leaq 0x33d4(%rip), %rsi      # 0xd699
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x14(%r15)
leaq 0x33d1(%rip), %rdi      # 0xd6a9
leaq 0x33f0(%rip), %rax      # 0xd6cf
cmoveq %rax, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2300
cmpl $0x0, 0x18(%r15)
js 0xa3a4
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 0xa33e
leaq (%r12,%rbx), %rax
testl %eax, %eax
jne 0xa33e
movl $0x25, %esi
movl $0x1, %edx
leaq 0x3376(%rip), %rdi      # 0xd6ac
movq %r14, %rcx
callq 0x2300
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
movl $0x20, %edi
cmpl $-0x3, %eax
jb 0xa36d
movl $0x44, %edi
leaq (%r12,%rbx), %rcx
addq $-0x4, %rcx
testl %ecx, %ecx
jne 0xa37e
cmpl $-0x3, %eax
jb 0xa38f
movl 0x18(%r15), %eax
cmpq %rax, %r12
je 0xa38f
movq %r14, %rsi
callq 0x21a0
leaq 0x1(%r12), %rax
movslq 0x18(%r15), %rcx
cmpq %rcx, %r12
movq %rax, %r12
jl 0xa303
movl $0xa, %edi
movq %r14, %rsi
callq 0x21a0
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rdi
leaq 0x1b67a(%rip), %r9      # 0x25a40
incq %rbp
cmpq %rdi, %rbp
jae 0xa3de
movslq 0x1b65f(%rip), %rax     # 0x25a34
cmpq %rax, %rbp
jl 0xa28c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Edilbert[P]BS9/bs9.c
// Function: 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 0x7dc57(%rip), %rdi     # 0x88050
movl 0x1b635(%rip), %edx     # 0x25a34
leaq 0x2d4d(%rip), %rsi      # 0xd153
xorl %eax, %eax
callq 0x2210
cmpl $0x0, 0x1b620(%rip)     # 0x25a34
jle 0xa463
leaq 0x1b62f(%rip), %r14     # 0x25a4c
leaq 0x32b2(%rip), %rbx      # 0xd6d6
xorl %r15d, %r15d
cmpb $0x0, -0x4(%r14)
jne 0xa433
movb $0x20, -0x4(%r14)
movq 0x7dc16(%rip), %rdi     # 0x88050
movsbl -0x4(%r14), %edx
movl (%r14), %ecx
movq -0xc(%r14), %r8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2210
incq %r15
movslq 0x1b5da(%rip), %rax     # 0x25a34
addq $0x30, %r14
cmpq %rax, %r15
jl 0xa427
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x1b5c4(%rip)     # 0x25a34
jle 0xa4bd
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1b5c2(%rip), %r14     # 0x25a40
leaq 0x325e(%rip), %rbx      # 0xd6e3
xorl %r15d, %r15d
cmpl $0xff0000, 0xc(%r14)    # imm = 0xFF0000
jne 0xa4a5
movq (%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2130
incl 0x1b587(%rip)           # 0x25a2c
incq %r15
movslq 0x1b585(%rip), %rax     # 0x25a34
addq $0x30, %r14
cmpq %rax, %r15
jl 0xa488
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b4ff(%rip), %rdi     # 0x25a10
movslq %eax, %r14
testq %rdi, %rdi
je 0xa54a
leaq 0x7ad60(%rip), %rax     # 0x85280
movl (%rax,%r14,4), %edx
leaq 0x7ada5(%rip), %rax     # 0x852d0
movl (%rax,%r14,4), %ecx
addl %edx, %ecx
leaq 0x7ae38(%rip), %rax     # 0x85370
movq (%rax,%r14,8), %r8
leaq 0x31c9(%rip), %rsi      # 0xd70c
xorl %eax, %eax
callq 0x2210
leaq 0x7ae1f(%rip), %rax     # 0x85370
movq (%rax,%r14,8), %rdi
leaq 0x31ce(%rip), %rsi      # 0xd72a
callq 0x22b0
testq %rax, %rax
je 0xa612
movq %rax, %rbx
leaq 0x7adac(%rip), %rax     # 0x85320
cmpl $0x0, (%rax,%r14,4)
js 0xa5c6
leaq 0x7acfe(%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 0xa621
leaq 0xf(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2300
testq %rax, %rax
je 0xa626
leaq 0x7acb3(%rip), %rax     # 0x85280
movslq (%rax,%r14,4), %rax
leaq 0xa678(%rip), %rdi      # 0x14c50
addq %rax, %rdi
leaq 0x7acee(%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 0xa617
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0xa61c
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_O1/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 0xa65e
movslq %edi, %rcx
movslq %edx, %rdx
xorl %eax, %eax
leaq 0xa60b(%rip), %rsi      # 0x14c50
movzwl (%rcx,%rsi), %edi
rolw $0x8, %di
movzwl %di, %edi
addl %edi, %eax
addq $0x2, %rcx
cmpq %rdx, %rcx
jl 0xa645
movzwl %ax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movslq %edi, %r15
leaq 0x7ac09(%rip), %rax     # 0x85280
movslq (%rax,%r15,4), %rcx
leaq 0x7ac4e(%rip), %rax     # 0x852d0
movslq (%rax,%r15,4), %rax
movq %rax, 0x10(%rsp)
addl %ecx, %eax
decl %eax
xorl %ebx, %ebx
leaq 0xa5b8(%rip), %r14      # 0x14c50
movq %rcx, %r13
cmpl %ecx, %eax
jle 0xa6bd
cltq
xorl %ebx, %ebx
movq %r13, %rcx
movzwl (%rcx,%r14), %edx
rolw $0x8, %dx
movzwl %dx, %edx
addl %edx, %ebx
addq $0x2, %rcx
cmpq %rax, %rcx
jl 0xa6a6
movq 0x1b34c(%rip), %rdi     # 0x25a10
testq %rdi, %rdi
movq 0x10(%rsp), %rcx
movq %r13, %rdx
je 0xa6fa
movq %rcx, %rbp
addl %edx, %ecx
decl %ecx
leaq 0x7ac91(%rip), %rax     # 0x85370
movq (%rax,%r15,8), %r8
leaq 0x3022(%rip), %rsi      # 0xd70c
movq %rdx, %r12
xorl %eax, %eax
callq 0x2210
movq %r12, %rdx
movq %rbp, %rcx
movb $0x53, 0x8(%rsp)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x9(%rsp)
movb %dh, 0xa(%rsp)
movb %dl, 0xb(%rsp)
movb %ch, 0xc(%rsp)
movb %cl, 0xd(%rsp)
movb %bh, 0xe(%rsp)
movb %bl, 0xf(%rsp)
leaq 0x7ac49(%rip), %rax     # 0x85370
movq (%rax,%r15,8), %rdi
leaq 0x2ff8(%rip), %rsi      # 0xd72a
callq 0x22b0
testq %rax, %rax
je 0xa797
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x8, %edx
movq %rax, %rcx
callq 0x2300
cmpq $0x7, %rax
jbe 0xa79c
addq %r13, %r14
movl $0x1, %esi
movq %r14, %rdi
movq 0x10(%rsp), %rbx
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2300
cmpq %rbx, %rax
jb 0xa7a1
movq %r15, %rdi
callq 0x2100
testl %eax, %eax
jne 0xa7a6
addq $0x18, %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_O1/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 0x2f7c(%rip), %rsi      # 0xd753
movq %rbx, %rdi
movl %r12d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
jne 0xa871
addl %ebp, %r12d
sarl $0x8, %ebp
addl %r12d, %ebp
testl %r15d, %r15d
jle 0xa83a
movl %r15d, %r12d
leaq 0x2f52(%rip), %r15      # 0xd75c
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 0xa86c
movzbl (%r14,%r13), %eax
addl %eax, %ebp
incq %r13
cmpq %r13, %r12
jne 0xa80d
notl %ebp
movzbl %bpl, %edx
leaq 0x2f1a(%rip), %rsi      # 0xd761
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2210
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
jne 0xa876
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_O1/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, 0x1a2fa(%rip)     # 0x24d70
jle 0xaac1
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7a98d(%rip), %r14     # 0x85410
xorl %ebx, %ebx
movl (%r14), %eax
movl %ebx, %edi
cmpl $0x2, %eax
je 0xaa9b
cmpl $0x1, %eax
jne 0xaaa2
callq 0xa87b
jmp 0xaaa7
callq 0xa65f
jmp 0xaaa7
callq 0xa4ff
incq %rbx
movslq 0x1a2bf(%rip), %rax     # 0x24d70
addq $0x4, %r14
cmpq %rax, %rbx
jl 0xaa85
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ffe(%rip), %rdi      # 0xdae0
callq 0x20a0
leaq 0x3010(%rip), %rdi      # 0xdafe
callq 0x20a0
leaq 0x300d(%rip), %rdi      # 0xdb07
callq 0x20a0
leaq 0x3029(%rip), %rdi      # 0xdb2f
callq 0x20a0
leaq 0x3032(%rip), %rdi      # 0xdb44
callq 0x20a0
leaq 0x3043(%rip), %rdi      # 0xdb61
callq 0x20a0
leaq 0x304a(%rip), %rdi      # 0xdb74
callq 0x20a0
leaq 0x3057(%rip), %rdi      # 0xdb8d
callq 0x20a0
leaq 0x3069(%rip), %rdi      # 0xdbab
callq 0x20a0
leaq 0x308f(%rip), %rdi      # 0xdbdd
callq 0x20a0
leaq 0x30a9(%rip), %rdi      # 0xdc03
callq 0x20a0
leaq 0x30c4(%rip), %rdi      # 0xdc2a
callq 0x20a0
leaq 0x30d8(%rip), %rdi      # 0xdc4a
callq 0x20a0
leaq 0x30dd(%rip), %rdi      # 0xdc5b
callq 0x20a0
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O1/mulle-nat[P]long-long-double-trouble/long-long.c
// Function: main
int   main( int argc, char *argv[])
{
   double  value;

   fprintf( stderr, "long-long (%d bytes): %lld - %lld\n", (int) sizeof( long long), LLONG_MIN, LLONG_MAX);
   fprintf( stderr, "double (%d bytes): %g - %g\n", (int) sizeof( double), DBL_MIN, DBL_MAX);

   assert( (double) LLONG_MAX <= DBL_MAX);

   // keep my code optimiza
   if( argc == 1)
      value = (double) LLONG_MAX;
   else
      value = (double) (LLONG_MAX - atoi( argv[ 1]));

   if( fits_llong( value))
      printf( "FITS\n");
   else
      printf( "NOPE\n");
   return( 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
movq 0x2f6a(%rip), %r12      # 0x3ff8
movq (%r12), %rdi
leaq 0x1(%rbx), %rcx
leaq 0xfb2(%rip), %rsi       # 0x204f
pushq $0x8
popq %r15
movl %r15d, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1040
movq (%r12), %rdi
leaq 0xfb9(%rip), %rsi       # 0x2072
movsd 0xf67(%rip), %xmm0      # 0x2028
movsd 0xf67(%rip), %xmm1      # 0x2030
movl %r15d, %edx
movb $0x2, %al
callq 0x1040
cmpl $0x1, %ebp
jne 0x10e2
movsd 0xf40(%rip), %xmm0      # 0x2020
jmp 0x10f5
movq 0x8(%r14), %rdi
callq 0x1050
cltq
subq %rax, %rbx
cvtsi2sd %rbx, %xmm0
callq 0x120c
testl %eax, %eax
leaq 0xf8b(%rip), %rax       # 0x208e
leaq 0xf89(%rip), %rdi       # 0x2093
cmoveq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/arena.c
// Function: mem
char	*mem(char *ptr, int idx, t_arena *arena, t_process *process)
{
	int	temp;

	temp = ptr - process->pc;
	temp %= MEM_SIZE;
	if (idx)
		temp %= IDX_MOD;
	if (process->pc + temp < arena->memory)
		return (process->pc + temp + MEM_SIZE);
	if (process->pc + temp >= arena->memory + MEM_SIZE)
		return (process->pc + temp - MEM_SIZE);
	return (process->pc + temp);
}

// Assembly:
movq 0x48(%rcx), %rax
subl %eax, %edi
leal 0xfff(%rdi), %ecx
testl %edi, %edi
cmovnsl %edi, %ecx
andl $0xfffff000, %ecx       # imm = 0xFFFFF000
movl %edi, %r8d
subl %ecx, %r8d
negl %ecx
addl %edi, %ecx
addl $0x1ff, %ecx            # imm = 0x1FF
testl %r8d, %r8d
cmovnsl %r8d, %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
movl %r8d, %edi
subl %ecx, %edi
testl %esi, %esi
cmovel %r8d, %edi
movslq %edi, %rcx
addq %rax, %rcx
movq (%rdx), %rdx
movl $0x1000, %esi           # imm = 0x1000
leaq (%rdx,%rsi), %rdi
xorl %eax, %eax
cmpq %rdi, %rcx
setb %al
shll $0xc, %eax
addq $-0x1000, %rax          # imm = 0xF000
cmpq %rdx, %rcx
cmovbq %rsi, %rax
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/arena.c
// Function: create_arena
t_arena	*create_arena(void)
{
	char	*memory;
	t_arena	*new;

	new = (t_arena *)ft_memalloc(sizeof(t_arena));
	memory = (char *)ft_memalloc(MEM_SIZE);
	new->memory = memory;
	new->players = NULL;
	new->cycle = 1;
	new->cycle_to_die = CYCLE_TO_DIE;
	new->last_check_cycle = 0;
	new->print_lives = 0;
	new->checks_without_decrement = 0;
	new->processes = NULL;
	new->dump_cycle = -1;
	new->display = NULL;
	return (new);
}

// Assembly:
pushq %rbx
movl $0x38, %edi
callq 0x5348
movq %rax, %rbx
movl $0x1000, %edi           # imm = 0x1000
callq 0x5348
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movabsq $0x60000000001, %rax    # imm = 0x60000000001
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movl %eax, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x1c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/arena.c
// Function: display_champions
void	display_champions(t_arena *arena)
{
	t_player	*i;

	ft_putendl("Introducing contestants...");
	i = arena->players;
	while (i != NULL)
	{
		ft_printf("* Player %d, weighing %d bytes, \"%s\" (\"%s\") !\n",
				i->id, i->champ_size, i->name, i->comment);
		i = i->next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4c1a(%rip), %rdi      # 0x7004
callq 0x539c
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x2421
leaq 0x4c20(%rip), %rbx      # 0x701f
movl (%r14), %esi
movl 0x20(%r14), %edx
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x541c
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0x23ff
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/arena.c
// Function: dump_memory
void	dump_memory(t_arena *arena)
{
	int			i;
	t_process	*p;

	p = arena->processes;
	ft_printf("\nDumping memory at cycle %d (%d processus):",
			arena->cycle, arena->processes->number);
	i = 0;
	while (i < MEM_SIZE)
	{
		p = arena->processes;
		if (i % 32 == 0 && i != MEM_SIZE - 1)
			ft_printf("\n%0#6x : ", i);
		ft_printf("%02x ", (unsigned char)arena->memory[i]);
		i++;
	}
	ft_putchar('\n');
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %esi
movq 0x28(%rdi), %rax
movl 0x5c(%rax), %edx
leaq 0x4c09(%rip), %rdi      # 0x704e
xorl %eax, %eax
callq 0x541c
leaq 0x4c27(%rip), %r14      # 0x707a
leaq 0x4c2a(%rip), %r15      # 0x7084
xorl %r12d, %r12d
testb $0x1f, %r12b
jne 0x2470
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x541c
movq (%rbx), %rax
movzbl (%rax,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x541c
incq %r12
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x245d
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5380
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/arena.c
// Function: destroy_arena
void	destroy_arena(t_arena *arena)
{
	if (arena->display != NULL)
		destroy_display(arena);
	while (arena->processes != NULL)
		kill_process(arena->processes);
	free_players(arena);
	free(arena->memory);
	free(arena);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
je 0x24bd
movq %rbx, %rdi
callq 0x4902
jmp 0x24bd
callq 0x2842
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
jne 0x24b8
movq %rbx, %rdi
callq 0x26e1
movq (%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/player.c
// Function: save_players
void			save_players(int ac, char **av, t_arena *arena)
{
	int			player_id;
	int			attempt;

	while (ac-- > 0)
	{
		player_id = 1;
		if (ft_strcmp("-n", av[0]) == 0)
		{
			check_player(av[1]);
			attempt = ft_atoi(av[1]);
			av += 2;
			ac -= 2;
			if (is_free_player_id(attempt, arena->players, ac, av))
				player_id = attempt;
		}
		else
			while (!is_free_player_id(player_id, arena->players, ac, av))
				player_id++;
		create_player(player_id, arena, av[0]);
		av++;
	}
}

// Assembly:
testl %edi, %edi
jle 0x25db
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x4b88(%rip), %r15      # 0x708a
movq (%r14), %rsi
movq %r15, %rdi
callq 0x5290
testl %eax, %eax
je 0x2530
decl %ebp
xorl %r12d, %r12d
incl %r12d
movq 0x8(%rbx), %rsi
movl %r12d, %edi
movl %ebp, %edx
movq %r14, %rcx
callq 0x25dc
testl %eax, %eax
je 0x2516
jmp 0x2567
movq 0x8(%r14), %rdi
callq 0x46bc
movq 0x8(%r14), %rdi
callq 0x52b8
movl %eax, %r12d
addq $0x10, %r14
addl $-0x3, %ebp
movq 0x8(%rbx), %rsi
movl %eax, %edi
movl %ebp, %edx
movq %r14, %rcx
callq 0x25dc
testl %eax, %eax
movl $0x1, %eax
cmovel %eax, %r12d
movq (%r14), %r13
movl $0x40, %edi
callq 0x5348
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x25a7
cmpl %r12d, (%rcx)
jle 0x258c
movq %rcx, 0x38(%rax)
movq %rax, 0x8(%rbx)
jmp 0x25b3
movq %rcx, %rdx
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
je 0x259d
cmpl %r12d, (%rcx)
jl 0x258c
movq %rcx, 0x38(%rax)
movq %rax, 0x38(%rdx)
jmp 0x25b3
movq %rax, 0x8(%rbx)
movq $0x0, 0x38(%rax)
movl %r12d, (%rax)
movl $0x0, 0x30(%rax)
movq %r13, 0x18(%rax)
addq $0x8, %r14
testl %ebp, %ebp
jg 0x2502
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/player.c
// Function: is_free_player_id
static int		is_free_player_id(int id, t_player *p, int ac, char **av)
{
	if (id < 1)
		return (0);
	ac--;
	av++;
	while (p != NULL)
	{
		if (p->id == id)
			return (0);
		p = p->next;
	}
	while (ac-- > 0)
	{
		if (ft_strcmp("-n", av[0]) == 0)
		{
			if (ft_atoi(av[1]) == id)
				return (0);
			av += 2;
			ac -= 2;
		}
		av++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testl %edi, %edi
jle 0x2646
movq %rcx, %r14
movl %edx, %ebp
movl %edi, %r15d
testq %rsi, %rsi
je 0x2602
cmpl %r15d, (%rsi)
je 0x2646
movq 0x38(%rsi), %rsi
jmp 0x25f2
cmpl $0x2, %ebp
jl 0x2641
decl %ebp
leaq 0x4a7a(%rip), %r12      # 0x708a
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x5290
testl %eax, %eax
je 0x2628
addq $0x8, %r14
decl %ebp
jmp 0x263d
movq 0x10(%r14), %rdi
callq 0x52b8
cmpl %r15d, %eax
je 0x2646
addq $0x18, %r14
addl $-0x3, %ebp
testl %ebp, %ebp
jg 0x2610
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/player.c
// Function: load_players
void			load_players(t_arena *arena)
{
	t_player	*i;
	int			n;
	int			total;

	total = 0;
	i = arena->players;
	while (i != NULL)
	{
		total++;
		i = i->next;
	}
	if (total < 1 || total > MAX_PLAYERS)
	{
		ft_putendl("Error : too many players");
		exit(1);
	}
	i = arena->players;
	n = 0;
	while (i != NULL)
	{
		i->begin = (arena->memory + n++ * MEM_SIZE / total);
		get_player_code(i);
		create_process(i->id, i->begin, arena, NULL);
		i = i->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
xorl %r12d, %r12d
testq %rax, %rax
je 0x2671
incl %r12d
movq 0x38(%rax), %rax
jmp 0x2663
leal -0x5(%r12), %eax
cmpl $-0x4, %eax
jb 0x26cb
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x26bf
xorl %r15d, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl %r12d
addq (%rbx), %rax
movq %rax, 0x28(%r14)
movq %r14, %rdi
callq 0x2a90
movl (%r14), %edi
movq 0x28(%r14), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2797
movq 0x38(%r14), %r14
addl $0x1000, %r15d          # imm = 0x1000
testq %r14, %r14
jne 0x2687
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x49bb(%rip), %rdi      # 0x708d
callq 0x539c
movl $0x1, %edi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/player.c
// Function: free_players
void			free_players(t_arena *arena)
{
	t_player	*next;
	t_player	*current;

	current = arena->players;
	while (current != NULL)
	{
		next = current->next;
		free(current->name);
		free(current->comment);
		free(current);
		current = next;
	}
	arena->players = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2718
movq 0x8(%r14), %rdi
movq 0x38(%r14), %r15
callq 0x2040
movq 0x10(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movq %r15, %r14
testq %r15, %r15
jne 0x26f2
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/process.c
// Function: create_copy_registers
void	create_copy_registers(t_process *p, t_process *parent, int player)
{
	int		i;

	i = -1;
	while (++i < REG_NUMBER)
	{
		if (parent == NULL)
		{
			if (i == 0)
				ft_write_big_endian(player, p->registers[0], REG_SIZE);
			else
				ft_bzero(p->registers[i], REG_SIZE);
		}
		else
			ft_memcpy(p->registers[i], parent->registers[i], REG_SIZE);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4(%rsi), %r12
addq $0x4, %r14
movslq %edx, %r15
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x275e
leaq (%r14,%r13), %rdi
leaq (%r12,%r13), %rsi
movl $0x4, %edx
callq 0x5260
jmp 0x2783
testq %r13, %r13
je 0x2773
leaq (%r14,%r13), %rdi
movl $0x4, %esi
callq 0x5250
jmp 0x2783
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x53c8
addq $0x4, %r13
cmpq $0x40, %r13
jne 0x2745
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/process.c
// Function: create_process
void	create_process(int player, char *pc, t_arena *arena, t_process *parent)
{
	t_process	*new;
	static int	i = 0;

	i++;
	new = (t_process*)malloc(sizeof(t_process));
	if (new == NULL)
		return ;
	new->player = player;
	new->pc = pc;
	new->carry = (parent == NULL) ? 0 : parent->carry;
	new->lives = (parent == NULL) ? 0 : parent->lives;
	new->count_lives = 0;
	new->cycles_to_wait = -1;
	new->op_code = 0;
	new->arena = arena;
	new->next = arena->processes;
	new->number = i;
	create_copy_registers(new, parent, player);
	arena->processes = new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movl %edi, %ebp
movl 0x8c18(%rip), %r13d     # 0xb3cc
incl %r13d
movl %r13d, 0x8c0e(%rip)     # 0xb3cc
movl $0x78, %edi
callq 0x2180
testq %rax, %rax
je 0x2825
movq %rax, %r15
movl %ebp, (%rax)
movq %r12, 0x48(%rax)
testq %r14, %r14
je 0x27e9
movb 0x50(%r14), %al
movb %al, 0x50(%r15)
movl 0x58(%r14), %eax
jmp 0x27f0
movb $0x0, 0x50(%r15)
xorl %eax, %eax
movl %eax, 0x58(%r15)
movq $0x0, 0x60(%r15)
movl $0xffffffff, 0x54(%r15) # imm = 0xFFFFFFFF
movq %rbx, 0x68(%r15)
movq 0x28(%rbx), %rax
movq %rax, 0x70(%r15)
movl %r13d, 0x5c(%r15)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2728
movq %r15, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/process.c
// Function: kill_process
void	kill_process(t_process *process)
{
	t_process	*i;

	if (process->arena->processes == process)
		process->arena->processes = process->next;
	else
	{
		i = process->arena->processes;
		while (i->next != process)
			i = i->next;
		i->next = process->next;
	}
	free(process);
}

// Assembly:
movq 0x68(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq %rdi, %rcx
je 0x2861
movq %rcx, %rax
movq 0x70(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x284f
addq $0x70, %rax
jmp 0x2865
addq $0x28, %rax
movq 0x70(%rdi), %rcx
movq %rcx, (%rax)
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/get_input.c
// Function: get_input
void				get_input(int fd, t_player *player, unsigned int *prog_size)
{
	int				ret;
	char			buf[BUFF_SIZE];
	int				i;

	i = 0;
	ret = 0;
	check_magic(fd, buf, ret, player);
	player->name = get_name(fd, buf, ret, i);
	*prog_size = get_prog_size(fd, buf, ret, i);
	if (*prog_size > CHAMP_MAX_SIZE)
	{
		ft_printf_fd(2,
				"Error: file %s has too large code(%d bytes > %d bytes)\n",
				player->file_name, *prog_size, CHAMP_MAX_SIZE);
		exit(1);
	}
	player->comment = get_comment(fd, buf, ret, i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a3a
movb 0xf(%rsp), %al
movb %al, 0x10(%rsp,%r12)
incq %r12
cmpq $0x4, %r12
jne 0x28a6
cmpb $0x0, 0x10(%rsp)
jne 0x2a55
cmpb $-0x16, 0x11(%rsp)
jne 0x2a55
cmpb $-0x7d, 0x12(%rsp)
jne 0x2a55
cmpb $-0xd, 0x13(%rsp)
jne 0x2a55
movl $0x81, %edi
callq 0x5348
movq %rax, %r15
movb $0x0, 0x80(%rax)
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
movl $0x1, %edx
movl %ebp, %edi
movq %r12, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a3a
movb 0xf(%rsp), %al
movb %al, (%r15,%r13)
incq %r13
cmpq $0x80, %r13
jne 0x2918
movl $0x4, %r13d
leaq 0xf(%rsp), %r12
movl $0x1, %edx
movl %ebp, %edi
movq %r12, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a3a
decl %r13d
jne 0x294f
movq %r15, 0x8(%rbx)
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a3a
movb 0xf(%rsp), %al
movb %al, 0x14(%rsp,%r12)
incq %r12
cmpq $0x4, %r12
jne 0x2978
leaq 0x14(%rsp), %rdi
movl $0x4, %esi
callq 0x53e5
movl %eax, (%r14)
cmpl $0x2ab, %eax            # imm = 0x2AB
jae 0x2a6e
movl $0x801, %edi            # imm = 0x801
callq 0x5348
movq %rax, %r14
movb $0x0, 0x800(%rax)
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a3a
movb 0xf(%rsp), %al
movb %al, (%r14,%r12)
incq %r12
cmpq $0x800, %r12            # imm = 0x800
jne 0x29db
movl $0x4, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a3a
decl %r12d
jne 0x2a0e
movq %r14, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x469d(%rip), %rdi      # 0x70de
movl $0x2, %esi
callq 0x53b0
movl $0x1, %edi
callq 0x21e0
movq 0x18(%rbx), %rdx
leaq 0x469e(%rip), %rsi      # 0x70fe
movl $0x2, %edi
xorl %eax, %eax
callq 0x55d0
jmp 0x2a4b
movq 0x18(%rbx), %rdx
leaq 0x462d(%rip), %rsi      # 0x70a6
movl $0x2, %edi
movl %eax, %ecx
movl $0x2aa, %r8d            # imm = 0x2AA
xorl %eax, %eax
callq 0x55d0
jmp 0x2a4b
nop