LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl %edi, 0x4(%rsp)
movq 0x1c9a4(%rip), %rdi     # 0x289f0
leaq 0x5299(%rip), %rsi      # 0x112ec
movb $0x0, %al
callq 0x21e0
movq 0x1c98f(%rip), %rdi     # 0x289f0
movslq 0x4(%rsp), %rcx
leaq 0x7a5c3(%rip), %rax     # 0x86630
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x5281(%rip), %rsi      # 0x112ff
movb $0x0, %al
callq 0x21e0
movq 0x1c964(%rip), %rdi     # 0x289f0
movslq 0x4(%rsp), %rcx
leaq 0x7a598(%rip), %rax     # 0x86630
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rax), %edx
leaq 0x5260(%rip), %rsi      # 0x11309
movb $0x0, %al
callq 0x21e0
movq 0x1c939(%rip), %rdi     # 0x289f0
movslq 0x4(%rsp), %rcx
leaq 0x7a56d(%rip), %rax     # 0x86630
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x14(%rax), %edx
leaq 0x523f(%rip), %rsi      # 0x11313
movb $0x0, %al
callq 0x21e0
movq 0x1c90e(%rip), %rdi     # 0x289f0
movslq 0x4(%rsp), %rcx
leaq 0x7a542(%rip), %rax     # 0x86630
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %edx
leaq 0x521e(%rip), %rsi      # 0x1131d
movb $0x0, %al
callq 0x21e0
movq 0x1c8e3(%rip), %rdi     # 0x289f0
movslq 0x4(%rsp), %rcx
leaq 0x7a517(%rip), %rax     # 0x86630
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq 0x51fc(%rip), %rsi      # 0x11327
movb $0x0, %al
callq 0x21e0
movq 0x1c8b7(%rip), %rdi     # 0x289f0
leaq 0x51ac(%rip), %rsi      # 0x112ec
movb $0x0, %al
callq 0x21e0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq 0x1b348(%rip), %rdi     # 0x289f0
movl 0x1a68a(%rip), %edx     # 0x27d38
movl 0xa060(%rip), %ecx      # 0x17714
leaq 0x3e20(%rip), %rsi      # 0x114db
movb $0x0, %al
callq 0x21e0
cmpb $0x0, 0x7a877(%rip)     # 0x87f40
je 0xd70f
movq 0x1b31e(%rip), %rax     # 0x289f0
movq %rax, (%rsp)
leaq 0x7a863(%rip), %rdi     # 0x87f40
callq 0x39f0
movq (%rsp), %rdi
movslq %eax, %rcx
leaq 0x1b330(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
leaq 0x3de4(%rip), %rsi      # 0x114e5
leaq 0x7a838(%rip), %rdx     # 0x87f40
movb $0x0, %al
callq 0x21e0
cmpb $0x0, 0x7d81a(%rip)     # 0x8af30
je 0xd734
movq 0x1b2d1(%rip), %rdi     # 0x289f0
leaq 0x2f04(%rip), %rsi      # 0x1062a
leaq 0x7d803(%rip), %rdx     # 0x8af30
movb $0x0, %al
callq 0x21e0
movq 0x1b2b5(%rip), %rdi     # 0x289f0
leaq 0x458f(%rip), %rsi      # 0x11cd1
movb $0x0, %al
callq 0x21e0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
leaq 0x3da1(%rip), %rax      # 0x114f9
movq %rax, (%rsp)
callq 0x3320
cmpl $0x0, 0x1b290(%rip)     # 0x289f8
jne 0xd7c1
cmpl $0x0, 0x7a27(%rip)      # 0x15198
je 0xd7a1
movq 0x1b26e(%rip), %rdi     # 0x289e8
movslq 0x1b25f(%rip), %rcx     # 0x289e0
leaq 0x1a8f8(%rip), %rax     # 0x28080
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
leaq 0x3d72(%rip), %rsi      # 0x1150c
movb $0x0, %al
callq 0x21e0
movq 0x1b240(%rip), %rdi     # 0x289e8
callq 0x2090
cmpl $0x0, %eax
je 0xd7bf
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
jmp 0xd7c1
movq 0x7a990(%rip), %rdi     # 0x88158
callq 0x20e0
cmpl $0x0, %eax
je 0xd7df
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
movslq 0x1b1fa(%rip), %rcx     # 0x289e0
leaq 0x1a893(%rip), %rax     # 0x28080
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2030
movl 0x1b1dd(%rip), %eax     # 0x289e0
addl $-0x1, %eax
movl %eax, 0x1b1d4(%rip)     # 0x289e0
movslq %eax, %rcx
leaq 0x1a86a(%rip), %rax     # 0x28080
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x7a931(%rip)     # 0x88158
movslq 0x1b1b2(%rip), %rcx     # 0x289e0
leaq 0x1a84b(%rip), %rax     # 0x28080
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0x1a4f3(%rip)     # 0x27d38
movq 0x7a90c(%rip), %rdx     # 0x88158
leaq 0x1a62d(%rip), %rdi     # 0x27e80
movl $0x100, %esi            # imm = 0x100
callq 0x2190
movl $0x0, 0x7ac29(%rip)     # 0x88490
movq 0x7a8ea(%rip), %rdi     # 0x88158
callq 0x2200
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq 0x7d068(%rip), %rdi     # 0x8b030
movl 0x1aa46(%rip), %edx     # 0x28a14
leaq 0x307e(%rip), %rsi      # 0x11053
movb $0x0, %al
callq 0x21e0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1aa26(%rip), %eax     # 0x28a14
jge 0xe08f
movslq 0x4(%rsp), %rcx
leaq 0x1aa20(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe027
movslq 0x4(%rsp), %rcx
leaq 0x1aa04(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb $0x20, 0x8(%rax)
movq 0x7d002(%rip), %rdi     # 0x8b030
movslq 0x4(%rsp), %rcx
leaq 0x1a9e6(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsbl 0x8(%rax), %edx
movslq 0x4(%rsp), %rcx
leaq 0x1a9cf(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movslq 0x4(%rsp), %rsi
leaq 0x1a9b9(%rip), %rax     # 0x28a20
imulq $0x30, %rsi, %rsi
addq %rsi, %rax
movq (%rax), %r8
leaq 0x35bc(%rip), %rsi      # 0x11634
movb $0x0, %al
callq 0x21e0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xdfe4
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1a961(%rip), %eax     # 0x28a14
jge 0xe113
movslq 0x4(%rsp), %rcx
leaq 0x1a95f(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0xff0000, 0xc(%rax)    # imm = 0xFF0000
jne 0xe104
movslq 0x4(%rsp), %rcx
leaq 0x1a943(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x3553(%rip), %rdi      # 0x11641
movb $0x0, %al
callq 0x2110
movl 0x1a911(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x1a908(%rip)     # 0x28a0c
jmp 0xe106
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe0a9
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: CmpAddress
int CmpAddress( const void *arg1, const void *arg2 )
{
   struct LabelStruct *Label1;
   struct LabelStruct *Label2;

   Label1 = (struct LabelStruct *) arg1;
   Label2 = (struct LabelStruct *) arg2;

   if (Label1->Address == Label2->Address) return 0;
   if (Label1->Address  > Label2->Address) return 1;
   return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jne 0xe15a
movl $0x0, -0x4(%rsp)
jmp 0xe17e
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jle 0xe176
movl $0x1, -0x4(%rsp)
jmp 0xe17e
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: CmpRefs
int CmpRefs( const void *arg1, const void *arg2 )
{
   struct LabelStruct *Label1;
   struct LabelStruct *Label2;

   Label1 = (struct LabelStruct *) arg1;
   Label2 = (struct LabelStruct *) arg2;

   if (Label1->NumRef == Label2->NumRef)
   {
      if (Label1->Address < Label2->Address) return  1;
      if (Label1->Address > Label2->Address) return -1;
      return 0;
   }
   if (Label1->NumRef  < Label2->NumRef) return 1;
   return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jne 0xe202
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xe1dc
movl $0x1, -0x4(%rsp)
jmp 0xe226
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jle 0xe1f8
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xe226
movl $0x0, -0x4(%rsp)
jmp 0xe226
movq -0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xe21e
movl $0x1, -0x4(%rsp)
jmp 0xe226
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
leaq 0x341e(%rip), %rax      # 0x1165d
movq %rax, (%rsp)
cmpq $0x0, 0x1a7a5(%rip)     # 0x289f0
je 0xe29f
movq 0x1a79c(%rip), %rdi     # 0x289f0
movslq 0x14(%rsp), %rcx
leaq 0x7a000(%rip), %rax     # 0x88260
movl (%rax,%rcx,4), %edx
movslq 0x14(%rsp), %rcx
leaq 0x79ff1(%rip), %rax     # 0x88260
movl (%rax,%rcx,4), %ecx
movslq 0x14(%rsp), %rsi
leaq 0x7a032(%rip), %rax     # 0x882b0
addl (%rax,%rsi,4), %ecx
movslq 0x14(%rsp), %rsi
leaq 0x7a0c3(%rip), %rax     # 0x88350
movq (%rax,%rsi,8), %r8
leaq 0x33d2(%rip), %rsi      # 0x1166a
movb $0x0, %al
callq 0x21e0
movslq 0x14(%rsp), %rcx
leaq 0x7a0a5(%rip), %rax     # 0x88350
movq (%rax,%rcx,8), %rdi
leaq 0x33d2(%rip), %rsi      # 0x11688
callq 0x2270
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x2670
movq %rax, 0x8(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x7a028(%rip), %rax     # 0x88300
cmpl $-0x1, (%rax,%rcx,4)
jle 0xe366
movslq 0x14(%rsp), %rcx
leaq 0x79f72(%rip), %rax     # 0x88260
movl (%rax,%rcx,4), %eax
andl $0xff, %eax
movb %al, 0x13(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x79f5a(%rip), %rax     # 0x88260
movl (%rax,%rcx,4), %eax
sarl $0x8, %eax
movb %al, 0x12(%rsp)
movq 0x8(%rsp), %rcx
leaq 0x12(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x22c0
cmpq $0x1, %rax
jae 0xe33a
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
movq 0x8(%rsp), %rcx
leaq 0x13(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x22c0
cmpq $0x1, %rax
jae 0xe364
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
jmp 0xe366
movslq 0x14(%rsp), %rcx
leaq 0x79eee(%rip), %rax     # 0x88260
movslq (%rax,%rcx,4), %rax
leaq 0x98b3(%rip), %rdi      # 0x17c30
addq %rax, %rdi
movslq 0x14(%rsp), %rcx
leaq 0x79f24(%rip), %rax     # 0x882b0
movslq (%rax,%rcx,4), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x22c0
movslq 0x14(%rsp), %rdx
leaq 0x79f05(%rip), %rcx     # 0x882b0
movslq (%rcx,%rdx,4), %rcx
cmpq %rcx, %rax
jae 0xe3c1
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
movq 0x8(%rsp), %rdi
callq 0x20e0
cmpl $0x0, %eax
je 0xe3dd
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
movl -0x4(%rsp), %ecx
addl -0x8(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xe45a
movslq -0x10(%rsp), %rcx
leaq 0x9809(%rip), %rax      # 0x17c30
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movl -0x10(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x97f1(%rip), %rcx      # 0x17c30
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rsp)
jmp 0xe408
movl -0xc(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
leaq 0x320c(%rip), %rax      # 0x1168b
movq %rax, (%rsp)
movslq 0x24(%rsp), %rcx
leaq 0x79dd1(%rip), %rax     # 0x88260
movl (%rax,%rcx,4), %eax
movl %eax, 0x20(%rsp)
movslq 0x24(%rsp), %rcx
leaq 0x79e0e(%rip), %rax     # 0x882b0
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
movl 0x20(%rsp), %edi
movl 0x1c(%rsp), %esi
callq 0xe3f0
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x1a52e(%rip)     # 0x289f0
je 0xe4f8
movq 0x1a525(%rip), %rdi     # 0x289f0
movl 0x20(%rsp), %edx
movl 0x20(%rsp), %ecx
addl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq 0x24(%rsp), %rsi
leaq 0x79e6a(%rip), %rax     # 0x88350
movq (%rax,%rsi,8), %r8
leaq 0x3179(%rip), %rsi      # 0x1166a
movb $0x0, %al
callq 0x21e0
movb $0x53, 0x10(%rsp)
movl 0x20(%rsp), %eax
sarl $0x10, %eax
movb %al, 0x11(%rsp)
movl 0x20(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, 0x12(%rsp)
movl 0x20(%rsp), %eax
andl $0xff, %eax
movb %al, 0x13(%rsp)
movl 0x1c(%rsp), %eax
sarl $0x8, %eax
movb %al, 0x14(%rsp)
movl 0x1c(%rsp), %eax
andl $0xff, %eax
movb %al, 0x15(%rsp)
movl 0x18(%rsp), %eax
sarl $0x8, %eax
movb %al, 0x16(%rsp)
movl 0x18(%rsp), %eax
andl $0xff, %eax
movb %al, 0x17(%rsp)
movslq 0x24(%rsp), %rcx
leaq 0x79def(%rip), %rax     # 0x88350
movq (%rax,%rcx,8), %rdi
leaq 0x311c(%rip), %rsi      # 0x11688
callq 0x2270
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x2670
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x1, %esi
movl $0x8, %edx
callq 0x22c0
cmpq $0x8, %rax
jae 0xe5ae
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
movslq 0x20(%rsp), %rax
leaq 0x9676(%rip), %rdi      # 0x17c30
addq %rax, %rdi
movslq 0x1c(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x22c0
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jae 0xe5e8
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
movq 0x8(%rsp), %rdi
callq 0x20e0
cmpl $0x0, %eax
je 0xe604
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
leaq 0x306e(%rip), %rax      # 0x116a0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x1fe4(%rip), %rsi      # 0x1062c
movb $0x0, %al
callq 0x21e0
movl 0x24(%rsp), %eax
addl $0x3, %eax
movl 0x20(%rsp), %ecx
andl $0xff, %ecx
addl %ecx, %eax
movl 0x20(%rsp), %ecx
sarl $0x8, %ecx
addl %ecx, %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
addl $0x3, %edx
movl 0x20(%rsp), %ecx
leaq 0x302b(%rip), %rsi      # 0x116b1
movb $0x0, %al
callq 0x21e0
movq 0x30(%rsp), %rdi
callq 0x2090
cmpl $0x0, %eax
je 0xe6aa
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xe71d
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x2fe4(%rip), %rsi      # 0x116ba
movb $0x0, %al
callq 0x21e0
movq 0x30(%rsp), %rdi
callq 0x2090
cmpl $0x0, %eax
je 0xe6fa
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe6b2
movq 0x30(%rsp), %rdi
movl 0x10(%rsp), %edx
xorl $-0x1, %edx
andl $0xff, %edx
leaq 0x2f89(%rip), %rsi      # 0x116bf
movb $0x0, %al
callq 0x21e0
movq 0x30(%rsp), %rdi
callq 0x2090
cmpl $0x0, %eax
je 0xe75a
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2670
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x192dd(%rip), %eax     # 0x27d50
jge 0xeac9
movslq 0x4(%rsp), %rcx
leaq 0x7996f(%rip), %rax     # 0x883f0
cmpl $0x1, (%rax,%rcx,4)
jne 0xea92
movl 0x4(%rsp), %edi
callq 0xe760
jmp 0xeaba
movslq 0x4(%rsp), %rcx
leaq 0x79952(%rip), %rax     # 0x883f0
cmpl $0x2, (%rax,%rcx,4)
jne 0xeaaf
movl 0x4(%rsp), %edi
callq 0xe470
jmp 0xeab8
movl 0x4(%rsp), %edi
callq 0xe230
jmp 0xeaba
jmp 0xeabc
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xea69
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x2bf6(%rip), %rdi      # 0x116fe
movb $0x0, %al
callq 0x2110
leaq 0x2c07(%rip), %rdi      # 0x1171d
movb $0x0, %al
callq 0x2110
leaq 0x2c03(%rip), %rdi      # 0x11727
movb $0x0, %al
callq 0x2110
leaq 0x2c1e(%rip), %rdi      # 0x11750
movb $0x0, %al
callq 0x2110
leaq 0x2c26(%rip), %rdi      # 0x11766
movb $0x0, %al
callq 0x2110
leaq 0x2c36(%rip), %rdi      # 0x11784
movb $0x0, %al
callq 0x2110
leaq 0x2c3c(%rip), %rdi      # 0x11798
movb $0x0, %al
callq 0x2110
leaq 0x2c48(%rip), %rdi      # 0x117b2
movb $0x0, %al
callq 0x2110
leaq 0x2c59(%rip), %rdi      # 0x117d1
movb $0x0, %al
callq 0x2110
leaq 0x2c7e(%rip), %rdi      # 0x11804
movb $0x0, %al
callq 0x2110
leaq 0x2c97(%rip), %rdi      # 0x1182b
movb $0x0, %al
callq 0x2110
leaq 0x2cb1(%rip), %rdi      # 0x11853
movb $0x0, %al
callq 0x2110
leaq 0x2cc4(%rip), %rdi      # 0x11874
movb $0x0, %al
callq 0x2110
leaq 0x2cc8(%rip), %rdi      # 0x11886
movb $0x0, %al
callq 0x2110
movl $0x1, %edi
callq 0x22b0
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x2ddc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe19(%rip), %rsi       # 0x203f
movl $0x8, %edx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movb $0x0, %al
callq 0x1040
movq 0x2dab(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe0b(%rip), %rsi       # 0x2062
movl $0x8, %edx
movsd 0xdb4(%rip), %xmm0      # 0x2018
movsd 0xdb4(%rip), %xmm1      # 0x2020
movb $0x2, %al
callq 0x1040
cmpl $0x1, 0x10(%rsp)
jne 0x1289
movsd 0xd8e(%rip), %xmm0      # 0x2010
movsd %xmm0, (%rsp)
jmp 0x12b1
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1050
movslq %eax, %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
callq 0x1160
cmpl $0x0, %eax
je 0x12d0
leaq 0xdb7(%rip), %rdi       # 0x207e
movb $0x0, %al
callq 0x1030
jmp 0x12de
leaq 0xdad(%rip), %rdi       # 0x2084
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2357
movl -0x2c(%rbp), %eax
movl $0x200, %ecx            # imm = 0x200
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x238a
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x8(%rbp)
jmp 0x23da
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jb 0x23c7
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
addq $-0x1000, %rax          # imm = 0xF000
movq %rax, -0x8(%rbp)
jmp 0x23da
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x70f0
movq %rax, -0x10(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x70f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x600, 0x14(%rax)      # imm = 0x600
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7b71(%rip), %rdi      # 0xa004
callq 0x7190
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24e4
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0x7b50(%rip), %rdi      # 0xa01f
movb $0x0, %al
callq 0x7320
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x24a4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x5c(%rax), %edx
leaq 0x7b2d(%rip), %rdi      # 0xa04e
movb $0x0, %al
callq 0x7320
movl $0x0, -0xc(%rbp)
cmpl $0x1000, -0xc(%rbp)     # imm = 0x1000
jge 0x2596
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x256e
cmpl $0xfff, -0xc(%rbp)      # imm = 0xFFF
je 0x256e
movl -0xc(%rbp), %esi
leaq 0x7b13(%rip), %rdi      # 0xa07a
movb $0x0, %al
callq 0x7320
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x7b00(%rip), %rdi      # 0xa084
movb $0x0, %al
callq 0x7320
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x252f
movl $0xa, %edi
callq 0x7160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x25d0
movq -0x8(%rbp), %rdi
callq 0x60d0
jmp 0x25d2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x25ec
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2c40
jmp 0x25d2
movq -0x8(%rbp), %rdi
callq 0x29d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
jle 0x2704
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x7a3e(%rip), %rdi      # 0xa08a
callq 0x6f10
cmpl $0x0, %eax
jne 0x26ac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5d20
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f90
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
callq 0x2710
cmpl $0x0, %eax
je 0x26aa
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x26e0
jmp 0x26ae
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
callq 0x2710
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x26d3
jmp 0x26de
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26ae
jmp 0x26e0
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x27f0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x2623
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
jge 0x2738
movl $0x0, -0x4(%rbp)
jmp 0x27e5
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2776
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x2768
movl $0x0, -0x4(%rbp)
jmp 0x27e5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x274d
jmp 0x2778
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x27de
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq 0x78f4(%rip), %rdi      # 0xa08a
callq 0x6f10
cmpl $0x0, %eax
jne 0x27d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f90
cmpl -0x8(%rbp), %eax
jne 0x27bb
movl $0x0, -0x4(%rbp)
jmp 0x27e5
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x2778
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/player.c
// Function: create_player
static void		create_player(int player_id, t_arena *arena, char *file_name)
{
	t_player	*new;
	t_player	*i;

	new = (t_player *)ft_memalloc(sizeof(t_player));
	if (arena->players == NULL)
	{
		arena->players = new;
		new->next = NULL;
	}
	else if (player_id < arena->players->id)
	{
		new->next = arena->players;
		arena->players = new;
	}
	else
	{
		i = arena->players;
		while (i->next != NULL && i->next->id < player_id)
			i = i->next;
		new->next = i->next;
		i->next = new;
	}
	new->id = player_id;
	new->last_live = 0;
	new->file_name = file_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x40, %edi
callq 0x70f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2839
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x28ca
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x2866
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x28c8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, -0x29(%rbp)
je 0x2895
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x289e
jmp 0x28ac
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2872
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x28ca
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x292d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x290f
cmpl $0x1, -0x18(%rbp)
jl 0x2939
cmpl $0x4, -0x18(%rbp)
jle 0x294f
leaq 0x774d(%rip), %rdi      # 0xa08d
callq 0x7190
movl $0x1, %edi
callq 0x21d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29c1
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
shll $0xc, %eax
cltd
idivl -0x18(%rbp)
cltq
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x30e0
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2af0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2962
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2a28
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x29e8
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x10, %eax
jge 0x2ae1
cmpq $0x0, -0x10(%rbp)
jne 0x2aac
cmpl $0x0, -0x18(%rbp)
jne 0x2a8d
movslq -0x14(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl $0x4, %edx
callq 0x71f0
jmp 0x2aaa
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl $0x4, %esi
callq 0x6e40
jmp 0x2adc
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl $0x4, %edx
callq 0x6e90
jmp 0x2a5a
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl 0xa947(%rip), %eax      # 0xd454
addl $0x1, %eax
movl %eax, 0xa93e(%rip)      # 0xd454
movl $0x78, %edi
callq 0x2170
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2b30
jmp 0x2bf2
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x2b53
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2b5e
movq -0x20(%rbp), %rax
movsbl 0x50(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x50(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x2b78
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x2b82
movq -0x20(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x70(%rax)
movl 0xa885(%rip), %ecx      # 0xd454
movq -0x28(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x4(%rbp), %edx
callq 0x2a40
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x28(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x2c74
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x2cb0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x2ca0
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2c84
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/process.c
// Function: count_processes
int		count_processes(t_arena *arena)
{
	t_process	*p;
	int			i;

	i = 0;
	p = arena->processes;
	while (p != NULL)
	{
		i++;
		p = p->next;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2cf9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2cdb
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rcx
callq 0x2dd0
movl -0x4(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x2ea0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x2f80
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x2aa, (%rax)          # imm = 0x2AA
jbe 0x2da8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl $0x2, %edi
leaq 0x7315(%rip), %rsi      # 0xa0a6
movl $0x2aa, %r8d            # imm = 0x2AA
movb $0x0, %al
callq 0x75c0
movl $0x1, %edi
callq 0x21d0
movl -0x4(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x3000
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/get_input.c
// Function: check_magic
static void			check_magic(int fd, char *buf, int ret, t_player *p)
{
	unsigned char	magic[4];
	int				i;

	i = 0;
	while (i < 4)
	{
		if ((ret = read(fd, buf, BUFF_SIZE)) == -1)
		{
			ft_putendl_fd("Error : The reading has failed.", 2);
			exit(1);
		}
		else
			magic[i] = buf[0];
		i++;
	}
	if (magic[0] != 0 || magic[1] != 234 || magic[2] != 131
			|| magic[3] != 243)
	{
		ft_printf_fd(2, "Error: File %s has an invalid header.\n",
				p->file_name);
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x2e40
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2110
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x2e27
leaq 0x72cb(%rip), %rdi      # 0xa0de
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movq -0x10(%rbp), %rax
movb (%rax), %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x24(%rbp,%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2ded
movzbl -0x24(%rbp), %eax
cmpl $0x0, %eax
jne 0x2e6a
movzbl -0x23(%rbp), %eax
cmpl $0xea, %eax
jne 0x2e6a
movzbl -0x22(%rbp), %eax
cmpl $0x83, %eax
jne 0x2e6a
movzbl -0x21(%rbp), %eax
cmpl $0xf3, %eax
je 0x2e8f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x2, %edi
leaq 0x7280(%rip), %rsi      # 0xa0fe
movb $0x0, %al
callq 0x75c0
movl $0x1, %edi
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/get_input.c
// Function: get_name
static char			*get_name(int fd, char *buf, int ret, int i)
{
	char	*name;

	name = ft_memalloc(PROG_NAME_LENGTH + 1);
	name[PROG_NAME_LENGTH] = '\0';
	while (i < PROG_NAME_LENGTH)
	{
		if ((ret = read(fd, buf, BUFF_SIZE)) == -1)
		{
			ft_putendl_fd("Error : The reading has failed.", 2);
			exit(1);
		}
		else
			name[i] = buf[0];
		i++;
	}
	while (i < PROG_NAME_LENGTH + 4)
	{
		if ((ret = read(fd, buf, BUFF_SIZE)) == -1)
		{
			ft_putendl_fd("Error : The reading has failed.", 2);
			exit(1);
		}
		i++;
	}
	return (name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x81, %edi
callq 0x70f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, 0x80(%rax)
cmpl $0x80, -0x18(%rbp)
jge 0x2f27
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2110
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x2f0b
leaq 0x71e7(%rip), %rdi      # 0xa0de
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movq -0x10(%rbp), %rax
movb (%rax), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2ece
jmp 0x2f29
cmpl $0x84, -0x18(%rbp)
jge 0x2f71
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2110
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x2f66
leaq 0x718c(%rip), %rdi      # 0xa0de
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2f29
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)