LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/umbrant[P]Non-blocking-Buffers/nameserver.c
// Function: dealloc_service
void dealloc_service(int slot)
{
  int i;

  for(i = 0;i < service_lists[slot].num_channels;i++) {
    free_lists[service_lists[slot].channel_ids[i]] = 0;
  }

  service_lists[slot].is_use = 0;  
  free(service_lists[slot].name);
  free(service_lists[slot].channel_ids);
}

// Assembly:
pushq %rbx
movslq %edi, %rax
leaq (%rax,%rax,4), %rax
leaq 0x3da3(%rip), %rcx      # 0x68e0
leaq (%rcx,%rax,8), %rbx
movslq 0x18(%rbx), %rax
testq %rax, %rax
jle 0x2b6a
movq 0x8(%rbx), %rcx
xorl %edx, %edx
leaq 0x3e59(%rip), %rsi      # 0x69b0
movslq (%rcx,%rdx,4), %rdi
movl $0x0, (%rsi,%rdi,4)
incq %rdx
cmpq %rdx, %rax
jne 0x2b57
movl $0x0, 0x20(%rbx)
movq (%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/dropletzhu[P]msuite/tcpserver.c
// Function: long_lived_server
void long_lived_server(int socket_fd)
{
	int result;
	fd_set readset;
	char buffer[2048];

	while (1) {
		do {
			FD_ZERO(&readset);
			FD_SET(socket_fd, &readset);
			result = select(socket_fd + 1, &readset, NULL, NULL, NULL);
		} while (result == -1 && errno == EINTR);

		if (result > 0) {
			if (FD_ISSET(socket_fd, &readset)) {
				do {
					result = recv(socket_fd, buffer, 2048, 0);
				} while (result > 0);

				if (result < 0) {
					printf("Error on recv(): %s\n", strerror(errno));
				}
			}
		} else if (result < 0) {
			printf("Error on select(): %s\n", strerror(errno));
			break;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x888, %rsp            # imm = 0x888
movl %edi, %ebx
leal 0x3f(%rbx), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %r13d
shlq %cl, %r13
sarl $0x6, %eax
movslq %eax, %r12
leal 0x1(%rbx), %ebp
movq %rsp, %r14
leaq 0x80(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
orq %r13, (%rsp,%r12,8)
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10e0
cmpl $-0x1, %eax
je 0x144d
testl %eax, %eax
jle 0x145d
testq %r13, (%rsp,%r12,8)
je 0x13c6
movl $0x800, %edx            # imm = 0x800
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x1030
testl %eax, %eax
jg 0x1414
jns 0x13c6
callq 0x1040
movl (%rax), %edi
callq 0x1160
leaq 0xbd8(%rip), %rdi       # 0x2016
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
jmp 0x13c6
callq 0x1040
cmpl $0x4, (%rax)
je 0x13c6
jmp 0x1468
jns 0x13c6
callq 0x1040
movl (%rax), %edi
callq 0x1160
leaq 0xbb5(%rip), %rdi       # 0x202b
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
addq $0x888, %rsp            # imm = 0x888
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: my_malloc
char * my_malloc(long size)
{
  char * help;
  if ( (help = (char *)malloc(size)) != NULL){
    totalMemory += size;
    return help;
  } else {
    Error(-NOMEM_ERR,"");
  }
  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3160
movq %rax, %rbx
testq %rax, %rax
je 0x3339
addq %r14, 0x11071(%rip)     # 0x143a8
jmp 0x334a
leaq 0x9c52(%rip), %rsi      # 0xcf92
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
callq 0xa1d8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writeConstByte
void writeConstByte(char c)
{
  if (Global.genesis >0 ){
    if ( code.Size + 1 > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      *code.Ptr++ = c;
      ++code.Size;
    }
  }
  Global.pc++;
}

// Assembly:
cmpl $0x0, 0x11068(%rip)     # 0x143c4
jle 0x33a9
cmpq $0x200000, 0x1126f(%rip) # imm = 0x200000
jl 0x338d
pushq %rax
leaq 0x9c1f(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x1103d(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
jmp 0x33a9
movq 0x1124c(%rip), %rax     # 0x145e0
leaq 0x1(%rax), %rcx
movq %rcx, 0x11241(%rip)     # 0x145e0
movb %dil, (%rax)
incq 0x1122f(%rip)           # 0x145d8
incl 0x11001(%rip)           # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writeRelocByte
void writeRelocByte(char c, int reloc)
{
  if (Global.genesis >0 ){
    if ( code.Size + 1 > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      if ( reloc ){
//      printf("reloc: %d: %04x\n",reloc,Global.pc);
      }
      *code.Ptr++ = c;
      ++code.Size;
    }
  }
  Global.pc++;
}

// Assembly:
cmpl $0x0, 0x1100d(%rip)     # 0x143c4
jle 0x3404
cmpq $0x200000, 0x11214(%rip) # imm = 0x200000
jl 0x33e8
pushq %rax
leaq 0x9bc4(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x10fe2(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
jmp 0x3404
movq 0x111f1(%rip), %rax     # 0x145e0
leaq 0x1(%rax), %rcx
movq %rcx, 0x111e6(%rip)     # 0x145e0
movb %dil, (%rax)
incq 0x111d4(%rip)           # 0x145d8
incl 0x10fa6(%rip)           # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writeSameBytes
void writeSameBytes(char c,int count)
{
  if (Global.genesis >0 ){
    if ( code.Size + count > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      int i = count+1;
      while ( --i ){
        *code.Ptr++ = c;
      }
      code.Size += count;
    }
  }
  Global.pc+=count;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
cmpl $0x0, 0x10f54(%rip)     # 0x143c4
jle 0x34d5
movslq %ebx, %rax
movq 0x1115c(%rip), %rcx     # 0x145d8
addq %rax, %rcx
cmpq $0x200001, %rcx         # imm = 0x200001
jl 0x34a5
leaq 0x9b03(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x10f21(%rip) # imm = 0xFFFFFFFF
jmp 0x34d5
testl %ebx, %ebx
je 0x34ce
movl %ebx, %ecx
movq 0x1112e(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x11123(%rip)     # 0x145e0
movb %dil, (%rdx)
decl %ecx
jne 0x34ab
addq 0x1110d(%rip), %rax     # 0x145d8
movq %rax, %rcx
movq %rcx, 0x11103(%rip)     # 0x145d8
addl %ebx, 0x10ed5(%rip)     # 0x143b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writeBytes
void writeBytes(char *src,int count)
{
  if (Global.genesis >0 ){
    if ( code.Size + count > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      int i = count+1;
      while ( --i ){
        *code.Ptr++ = *src++;
      }
      code.Size += count;
    }
  }
  Global.pc+=count;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
cmpl $0x0, 0x10edd(%rip)     # 0x143c4
jle 0x3555
movslq %ebx, %rax
movq 0x110e5(%rip), %rcx     # 0x145d8
addq %rax, %rcx
cmpq $0x200001, %rcx         # imm = 0x200001
jl 0x351c
leaq 0x9a8c(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x10eaa(%rip) # imm = 0xFFFFFFFF
jmp 0x3555
testl %ebx, %ebx
je 0x354e
movl %ebx, %ecx
xorl %edx, %edx
movb (%rdi,%rdx), %sil
movq 0x110b1(%rip), %r8      # 0x145e0
leaq 0x1(%r8), %r9
movq %r9, 0x110a6(%rip)      # 0x145e0
movb %sil, (%r8)
incq %rdx
cmpl %edx, %ecx
jne 0x3524
addq 0x1108d(%rip), %rax     # 0x145d8
movq %rax, %rcx
movq %rcx, 0x11083(%rip)     # 0x145d8
addl %ebx, 0x10e55(%rip)     # 0x143b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writeWordLittle
void writeWordLittle(short w)
{
  if (Global.genesis >0 ){
    if ( code.Size + 2 > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      *code.Ptr++ = (char) (w & 0xff);
      *code.Ptr++ = (char) (w >> 8);
      code.Size += 2;
    }
  }
  Global.pc+=2;
}

// Assembly:
cmpl $0x0, 0x10e60(%rip)     # 0x143c4
jle 0x35c7
cmpq $0x1fffff, 0x11067(%rip) # imm = 0x1FFFFF
jl 0x3595
pushq %rax
leaq 0x9a17(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x10e35(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
jmp 0x35c7
movl %edi, %eax
movq 0x11042(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x11037(%rip)     # 0x145e0
movb %al, (%rcx)
movq 0x1102e(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x11023(%rip)     # 0x145e0
movb %ah, (%rcx)
addq $0x2, 0x11011(%rip)     # 0x145d8
addl $0x2, 0x10de2(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writeWordBig
void writeWordBig(short w)
{
  //  printf("%04x ",w & 0xffff);
  if (Global.genesis >0 ){
    if ( code.Size + 2 > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      *code.Ptr++ = (char) (w >> 8);
      *code.Ptr++ = (char) (w & 0xff);
      code.Size += 2;
    }
  }
  Global.pc+=2;
}

// Assembly:
cmpl $0x0, 0x10dee(%rip)     # 0x143c4
jle 0x3639
cmpq $0x1fffff, 0x10ff5(%rip) # imm = 0x1FFFFF
jl 0x3607
pushq %rax
leaq 0x99a5(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x10dc3(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
jmp 0x3639
movl %edi, %eax
movq 0x10fd0(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10fc5(%rip)     # 0x145e0
movb %ah, (%rcx)
movq 0x10fbc(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10fb1(%rip)     # 0x145e0
movb %al, (%rcx)
addq $0x2, 0x10f9f(%rip)     # 0x145d8
addl $0x2, 0x10d70(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writeLongLittle
void writeLongLittle(int32_t l)
{
  if (Global.genesis >0 ){
    if ( code.Size + 4 > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      *code.Ptr++ = (char) (l & 0xff);
      *code.Ptr++ = (char) (l >> 8);
      *code.Ptr++ = (char) (l >> 16);
      *code.Ptr++ = (char) (l >> 24);
      code.Size += 4;
    }
  }
  Global.pc+=4;
}

// Assembly:
cmpl $0x0, 0x10d7c(%rip)     # 0x143c4
jle 0x36df
cmpq $0x1ffffd, 0x10f7f(%rip) # imm = 0x1FFFFD
jl 0x367d
pushq %rax
leaq 0x992f(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x10d4d(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
jmp 0x36df
movl %edi, %eax
movq 0x10f5a(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10f4f(%rip)     # 0x145e0
movb %al, (%rcx)
movq 0x10f46(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10f3b(%rip)     # 0x145e0
movb %ah, (%rcx)
movl %edi, %ecx
shrl $0x10, %ecx
movq 0x10f2d(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10f22(%rip)     # 0x145e0
movb %cl, (%rdx)
shrl $0x18, %eax
movq 0x10f16(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10f0b(%rip)     # 0x145e0
movb %al, (%rcx)
addq $0x4, 0x10ef9(%rip)     # 0x145d8
addl $0x4, 0x10cca(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: writePhraseLittle
void writePhraseLittle(int64_t l)
{
  if (Global.genesis >0 ){
    if ( code.Size + 4 > MAX_CODE_SIZE ){
      Error(CODEMEM_ERR,"");
      Global.genesis = -1;
    } else {
      *code.Ptr++ = (char) (l & 0xff);
      *code.Ptr++ = (char) (l >> 8);
      *code.Ptr++ = (char) (l >> 16);
      *code.Ptr++ = (char) (l >> 24);
      *code.Ptr++ = (char) (l >> 32);
      *code.Ptr++ = (char) (l >> 40);
      *code.Ptr++ = (char) (l >> 48);
      *code.Ptr++ = (char) (l >> 56);
      code.Size += 8;
    }
  }
  Global.pc+=4;
}

// Assembly:
cmpl $0x0, 0x10c2e(%rip)     # 0x143c4
jle 0x389c
cmpq $0x1ffffd, 0x10e31(%rip) # imm = 0x1FFFFD
jl 0x37ce
pushq %rax
leaq 0x97e1(%rip), %rsi      # 0xcf92
movl $0x15, %edi
callq 0xa1d8
movl $0xffffffff, 0x10bff(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
jmp 0x389c
movq %rdi, %rax
movq 0x10e08(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10dfd(%rip)     # 0x145e0
movb %al, (%rcx)
movq 0x10df4(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10de9(%rip)     # 0x145e0
movb %ah, (%rcx)
movl %eax, %ecx
shrl $0x10, %ecx
movq 0x10ddb(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10dd0(%rip)     # 0x145e0
movb %cl, (%rdx)
movl %eax, %ecx
shrl $0x18, %ecx
movq 0x10dc2(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10db7(%rip)     # 0x145e0
movb %cl, (%rdx)
movq %rdi, %rcx
shrq $0x20, %rcx
movq 0x10da7(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10d9c(%rip)     # 0x145e0
movb %cl, (%rdx)
movq %rdi, %rcx
shrq $0x28, %rcx
movq 0x10d8c(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10d81(%rip)     # 0x145e0
movb %cl, (%rdx)
movq %rdi, %rcx
shrq $0x30, %rcx
movq 0x10d71(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10d66(%rip)     # 0x145e0
movb %cl, (%rdx)
shrq $0x38, %rax
movq 0x10d59(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10d4e(%rip)     # 0x145e0
movb %al, (%rcx)
addq $0x8, 0x10d3c(%rip)     # 0x145d8
addl $0x4, 0x10b0d(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: LoadFile
int LoadFile(char *dst, long offset, long max_len, char *fn, long *len)
{
  FILE *f;
  size_t readlen;

  ConvertFilename(fn);

  if ( (f = fopen(fn,"rb")) == NULL ) return Error(-FILE_ERR,fn);

  if ( offset ){
    fseek(f,offset,SEEK_SET);
  }

  readlen = fread(dst,1,max_len,f);

  *len = (long)readlen;

  fclose( f);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rcx, %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x39fe
testl %ecx, %ecx
jne 0x3a01
jmp 0x3a06
movb $0x2f, (%rax)
incq %rax
jmp 0x39f0
leaq 0x86bb(%rip), %rsi      # 0xc0c8
movq %r13, %rdi
callq 0x3190
testq %rax, %rax
je 0x3a5e
movq %rax, %rbp
testq %r12, %r12
je 0x3a2f
movq %rbp, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3170
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbp, %rcx
callq 0x3090
movq %rax, (%rbx)
movq %rbp, %rdi
callq 0x30a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa1d8
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: CheckForUnsolvedLocals
void CheckForUnsolvedLocals()
{
  if ( refFirst ){
    REFERENCE *ptr1,*ptr = refFirst;
    int flag = 1;

    while ( ptr ){
      ptr1 = ptr->up;

      if ( (ptr->unknown->type & (LOCAL|MACRO)) == LOCAL){
        if ( flag ){
          Error(UNSOLVED_ERR,"local");
          flag=0;
        }
        printf("<%32s> [%5d %s]\n",ptr->unknown->name,
               ptr->line+1,file_list[ptr->file].name);
        ptr->unknown = 0;

        if ( ptr->down ){
          ptr->down->up = ptr->up;
        }
        if ( ptr->up ){
          ptr->up->down = ptr->down;
        }
        if ( ptr == refFirst ) refFirst = ptr->up;
        if ( ptr == refLast ) refLast = ptr->down;
        free(ptr);
      }
      ptr = ptr1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1e8a7(%rip), %r12     # 0x22da0
movq (%r12), %r15
testq %r15, %r15
je 0x45bc
movl $0x1, %eax
leaq 0x102ce(%rip), %r13     # 0x147e0
leaq 0x8a7a(%rip), %rbx      # 0xcf93
leaq 0x1e888(%rip), %rbp     # 0x22da8
movq (%r15), %r14
movq 0x38(%r15), %rsi
movl 0x4(%rsi), %ecx
andl $0x6, %ecx
cmpl $0x2, %ecx
jne 0x45b0
testl %eax, %eax
je 0x454b
movl $0x1d, %edi
leaq 0x8af2(%rip), %rsi      # 0xd034
callq 0xa1d8
movq 0x38(%r15), %rsi
addq $0x38, %rsi
movl 0x14(%r15), %edx
incl %edx
movslq 0x18(%r15), %rax
movq %rax, %rcx
shlq $0x9, %rcx
leaq (%rcx,%rax,4), %rax
leaq (%rax,%r13), %rcx
addq $0x4, %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c0
movq (%r15), %rax
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x4585
movq %rax, (%rcx)
testq %rax, %rax
je 0x458e
movq %rcx, 0x8(%rax)
cmpq (%r12), %r15
jne 0x4598
movq %rax, (%r12)
cmpq (%rbp), %r15
jne 0x45a6
movq 0x8(%r15), %rax
movq %rax, (%rbp)
movq %r15, %rdi
callq 0x3050
xorl %eax, %eax
movq %r14, %r15
testq %r14, %r14
jne 0x4520
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/lyxass.c
// Function: checkCode
int checkCode(char * s,int firstCol)
{
  int err;

  if ( (err = CheckPseudo(s)) >= 0) return err;

  if ( Current.Macro.Define ) return 0;

  if ( (err = CheckMnemonic(s)) >= 0) return err;

  if ( !(err = CheckMacro(s)) && firstCol ){
    return Error(SYNTAX_ERR,"");
  }
  return err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x8011
testl %eax, %eax
jns 0x4818
xorl %eax, %eax
cmpl $0x0, 0xfe38(%rip)      # 0x14614
jne 0x4818
movq %r14, %rdi
callq 0x940c
testl %eax, %eax
jns 0x4818
movq %r14, %rdi
callq 0x9fbf
testl %eax, %eax
setne %cl
testl %ebx, %ebx
sete %dl
orb %cl, %dl
jne 0x4818
leaq 0x878b(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa1d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: GetChar
int GetChar()
{
  if ( Current.SrcPtr ){
    ch = *Current.SrcPtr++;
    next_ch = *Current.SrcPtr;
  } else {
    ch = EOF;
    next_ch = EOF;
  }

  switch ( ch ){
  case 0 :
  case EOF:
    ch = EOF;
    Current.SrcPtr = NULL;
    break;
  case 0xA:
    ch = EOL;
    break;
  case '\r':             // replace CR by SPACE
  case '\t':
  case ' ':
    ch = SPACE;
    break;
  default:
    ;
  }
  return ( ch != EOF && ch != EOL );
}

// Assembly:
leaq 0xfaf1(%rip), %rax      # 0x14608
movq 0x198(%rax), %rsi
testq %rsi, %rsi
je 0x4b68
leaq 0x1(%rsi), %rcx
movq %rcx, 0x198(%rax)
movzbl (%rsi), %edx
movsbl %dl, %ecx
movl %ecx, 0x182d6(%rip)     # 0x1ce10
movsbl 0x1(%rsi), %esi
movl %esi, 0x182d0(%rip)     # 0x1ce14
cmpl $0xc, %edx
jg 0x4b8e
testl %edx, %edx
je 0x4b72
cmpl $0x9, %edx
je 0x4ba2
cmpl $0xa, %edx
jne 0x4bb1
movl $0xfffffffe, 0x182af(%rip) # imm = 0xFFFFFFFE
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x4bb1
movl $0xffffffff, 0x182a2(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x18294(%rip) # imm = 0xFFFFFFFF
movq $0x0, 0x198(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x4bb1
cmpl $0xd, %edx
je 0x4ba2
cmpl $0x20, %edx
je 0x4ba2
cmpl $0xff, %edx
je 0x4b72
jmp 0x4bb1
movl $0x20, 0x18264(%rip)    # 0x1ce10
movl $0x20, %ecx
xorl %eax, %eax
cmpl $-0x2, %ecx
setb %al
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: InsertMacroVar
char * InsertMacroVar(char *ptr,int var)
{
  char *ptr2;

  ptr2 = macrovars[Current.Macro.Processing-1][var];
  while ( *ptr2 )
    *ptr++ = *ptr2++;

  return ptr;
}

// Assembly:
movq %rdi, %rax
leaq 0xfa44(%rip), %rcx      # 0x14608
movslq 0x8(%rcx), %rcx
leaq (%rcx,%rcx,4), %rdx
shlq $0x8, %rdx
movslq %esi, %rcx
leaq (%rcx,%rcx,4), %rsi
shlq $0x4, %rsi
leaq 0x191be(%rip), %rcx     # 0x1dda0
addq %rdx, %rcx
movb -0x500(%rsi,%rcx), %cl
testb %cl, %cl
je 0x4c12
addq %rsi, %rdx
leaq 0x191a6(%rip), %rsi     # 0x1dda0
addq %rsi, %rdx
addq $-0x4ff, %rdx           # imm = 0xFB01
movb %cl, (%rax)
incq %rax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x4c04
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: GetAtom
int GetAtom(void)
{
  last_atom = atom;
  atom = *srcLinePtr++;
  next_atom = *srcLinePtr;

  if ( !atom ) srcLinePtr--;

  return atom;
}

// Assembly:
movl 0x18010(%rip), %eax     # 0x1cf30
movl %eax, 0x1800e(%rip)     # 0x1cf34
movq 0x17ff3(%rip), %rcx     # 0x1cf20
leaq 0x1(%rcx), %rax
movq %rax, 0x17fe8(%rip)     # 0x1cf20
movsbl (%rcx), %eax
movl %eax, 0x17fef(%rip)     # 0x1cf30
movsbl 0x1(%rcx), %edx
movl %edx, 0x17fed(%rip)     # 0x1cf38
testl %eax, %eax
je 0x4f50
retq
movq %rcx, 0x17fc9(%rip)     # 0x1cf20
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: TestAtom
int TestAtom(int x)
{
  KillSpace();
  if ( atom == (x) ){
    GetAtom();
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x4ff7
xorl %eax, %eax
cmpl %ebx, 0x17f78(%rip)     # 0x1cf30
jne 0x4ff5
movl %ebx, 0x17f74(%rip)     # 0x1cf34
movq 0x17f59(%rip), %rcx     # 0x1cf20
leaq 0x1(%rcx), %rax
movq %rax, 0x17f4e(%rip)     # 0x1cf20
movsbl (%rcx), %edx
movl %edx, 0x17f55(%rip)     # 0x1cf30
movsbl 0x1(%rcx), %eax
movl %eax, 0x17f53(%rip)     # 0x1cf38
movl $0x1, %eax
testl %edx, %edx
jne 0x4ff5
movq %rcx, 0x17f2b(%rip)     # 0x1cf20
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: TestAtomOR
int TestAtomOR(int x, int y)
{
  KillSpace();
  if ( atom == x || atom == y){
    GetAtom();
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x4ff7
movl 0x17ed1(%rip), %ecx     # 0x1cf30
cmpl %ebp, %ecx
setne %dl
cmpl %ebx, %ecx
setne %sil
xorl %eax, %eax
testb %sil, %dl
jne 0x50ac
movl %ecx, 0x17ebd(%rip)     # 0x1cf34
movq 0x17ea2(%rip), %rcx     # 0x1cf20
leaq 0x1(%rcx), %rax
movq %rax, 0x17e97(%rip)     # 0x1cf20
movsbl (%rcx), %edx
movl %edx, 0x17e9e(%rip)     # 0x1cf30
movsbl 0x1(%rcx), %eax
movl %eax, 0x17e9c(%rip)     # 0x1cf38
movl $0x1, %eax
testl %edx, %edx
jne 0x50ac
movq %rcx, 0x17e74(%rip)     # 0x1cf20
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: GetString
int GetString(char * ptr, char endmark)
{
  while ( atom && atom != endmark ){
    *ptr++ = atom;
    GetAtom();
  }
  *ptr = 0;

  if ( TestAtom(endmark) ){
    return 1;
  } else {
    return 0;
  }
}

// Assembly:
movl 0x17e77(%rip), %eax     # 0x1cf30
testl %eax, %eax
sete %cl
cmpl %esi, %eax
sete %dl
orb %cl, %dl
jne 0x511a
incq %rdi
movq %rdi, %rcx
movq %rcx, %rdi
movb %al, -0x1(%rcx)
movl 0x17e57(%rip), %eax     # 0x1cf30
movl %eax, 0x17e55(%rip)     # 0x1cf34
movq 0x17e3a(%rip), %rcx     # 0x1cf20
leaq 0x1(%rcx), %rax
movq %rax, 0x17e2f(%rip)     # 0x1cf20
movsbl (%rcx), %eax
movl %eax, 0x17e36(%rip)     # 0x1cf30
movsbl 0x1(%rcx), %edx
movl %edx, 0x17e34(%rip)     # 0x1cf38
testl %eax, %eax
je 0x5113
leaq 0x1(%rdi), %rcx
cmpb %sil, %al
jne 0x50cd
jmp 0x511a
movq %rcx, 0x17e06(%rip)     # 0x1cf20
movb $0x0, (%rdi)
movl %esi, %edi
jmp 0x4fa8
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: GetFileName
int GetFileName()
{
  int save;
  char help[80];
  int i;

  KillSpace();
  if ( atom != '"' && atom != '<' && atom != '\'') return Error(SYNTAX_ERR,"");
  if ( atom == '<' )
    save = '>';
  else
    save = atom;

  GetAtom();

  if ( !GetString( help, save ) ) return  Error(SYNTAX_ERR,"");

  memset(filename,0,512);

  if ( save == '>' && bll_root && sourceMode == LYNX){
    strcpy(filename,bll_root);
  } else if ( save == '>' && bjl_root && (sourceMode == JAGUAR_GPU || sourceMode == JAGUAR_DSP) ){
    strcpy(filename,bjl_root);
  } else {
    strcpy(filename,Global.Path);
  }

  i = (int)strlen(filename);
  if ( i && filename[i-1] != '/' && filename[i-1] != '\\'){
    filename[i] = '/';
  }
  if ( save == '\'' ) {
    char *ptr = help;
    char c;
    while ( (c = *ptr) ){
      *ptr++ = toupper(c);
    }
  }

  strcat(filename,help);

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
callq 0x4ff7
movl 0x17db4(%rip), %eax     # 0x1cf30
cmpl $0x22, %eax
je 0x5195
cmpl $0x27, %eax
je 0x5195
movl $0x3e, %ebp
cmpl $0x3c, %eax
je 0x5197
jmp 0x52da
movl %eax, %ebp
movl %eax, 0x17d97(%rip)     # 0x1cf34
movq 0x17d7c(%rip), %rax     # 0x1cf20
leaq 0x1(%rax), %rcx
movq %rcx, 0x17d71(%rip)     # 0x1cf20
movsbl (%rax), %ecx
movl %ecx, 0x17d78(%rip)     # 0x1cf30
movsbl 0x1(%rax), %edx
movl %edx, 0x17d76(%rip)     # 0x1cf38
testl %ecx, %ecx
jne 0x51cd
movq %rax, 0x17d53(%rip)     # 0x1cf20
movsbl %bpl, %esi
movq %rsp, %rdi
callq 0x50b3
testl %eax, %eax
je 0x52da
leaq 0x17908(%rip), %rdi     # 0x1caf0
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x30d0
movl %ebp, %ecx
xorl $0x3e, %ecx
leaq 0xf5c8(%rip), %rax      # 0x147c8
movq (%rax), %rsi
testq %rsi, %rsi
setne %dl
leaq 0xf3e0(%rip), %rax      # 0x145f0
movl (%rax), %eax
movl %eax, %edi
xorl $0x1, %edi
orl %ecx, %edi
sete %cl
testb %dl, %cl
jne 0x5250
leaq 0xf5a9(%rip), %rcx      # 0x147d0
movq (%rcx), %rcx
andl $-0x2, %eax
leaq 0xf17c(%rip), %rdx      # 0x143b0
addq $0x20, %rdx
cmpl $0x2, %eax
movq %rdx, %rsi
cmoveq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rdx, %rsi
cmpl $0x3e, %ebp
cmovneq %rdx, %rsi
leaq 0x17899(%rip), %rbx     # 0x1caf0
movq %rbx, %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0x5296
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
sarq $0x20, %rcx
movzbl (%rbx,%rcx), %ecx
cmpl $0x2f, %ecx
je 0x5296
cmpl $0x5c, %ecx
je 0x5296
sarq $0x20, %rax
movb $0x2f, (%rbx,%rax)
cmpl $0x27, %ebp
jne 0x52c2
movb (%rsp), %bl
testb %bl, %bl
je 0x52c2
callq 0x3030
movq (%rax), %rax
leaq 0x1(%rsp), %rcx
movsbq %bl, %rdx
movb (%rax,%rdx,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bl
incq %rcx
testb %bl, %bl
jne 0x52af
leaq 0x17827(%rip), %rdi     # 0x1caf0
movq %rsp, %rsi
callq 0x31a0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7cb1(%rip), %rsi      # 0xcf92
movl $0x12, %edi
addq $0x58, %rsp
popq %rbx
popq %rbp
jmp 0xa1d8
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/parser.c
// Function: GetCmd
int GetCmd(void)
{
  extern int LabelTable[256];

  int len = 0;
  char *ptr = Current.Cmd;

  memset(Current.Cmd, 0, 80);
  Current.CmdLen = 0;

  if ( KillSpace() ){
    if (isalpha(atom) || atom == '_' || atom == '.' )
      do{
        *ptr++ = atom;
        len++;
      }while ( GetAtom() && (LabelTable[atom] || atom == '.') );
  }
  Current.CmdLen = len;
  *ptr++ = 0;
  return (len == 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorps %xmm0, %xmm0
leaq 0xec7d(%rip), %rbx      # 0x14608
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
movl $0x0, 0xe0(%rbx)
callq 0x4ff7
xorl %r14d, %r14d
testl %eax, %eax
je 0x5a5c
callq 0x31e0
movq (%rax), %rcx
movslq 0x17559(%rip), %rax     # 0x1cf30
movzwl (%rcx,%rax,2), %ecx
btl $0xa, %ecx
jb 0x59ef
cmpl $0x5f, %eax
je 0x59ef
cmpl $0x2e, %eax
jne 0x5a71
movl $0x95, %edi
addq 0xd5e5(%rip), %rdi      # 0x12fe0
movq 0x1751e(%rip), %rdx     # 0x1cf20
incq %rdx
movl $0x1, %r8d
leaq 0x17d9e(%rip), %rsi     # 0x1d7b0
movl %r8d, %r14d
movq %rdi, %rcx
movb %al, -0x1(%rdi)
movl %eax, 0x17513(%rip)     # 0x1cf34
movq %rdx, 0x174f8(%rip)     # 0x1cf20
movsbl -0x1(%rdx), %eax
movl %eax, 0x174fe(%rip)     # 0x1cf30
movsbl (%rdx), %edi
movl %edi, 0x174fd(%rip)     # 0x1cf38
testl %eax, %eax
je 0x5a65
movslq %eax, %r9
incq %rdx
leal 0x1(%r14), %r8d
leaq 0x1(%rcx), %rdi
cmpb $0x2e, %r9b
je 0x5a12
cmpl $0x0, (%rsi,%r9,4)
jne 0x5a12
jmp 0x5a7d
leaq 0x94(%rbx), %rcx
jmp 0x5a7d
decq %rdx
movq %rdx, 0x174b1(%rip)     # 0x1cf20
jmp 0x5a7d
movl $0x94, %ecx
addq 0xd563(%rip), %rcx      # 0x12fe0
movl %r14d, 0x90(%rbx)
movb $0x0, (%rcx)
xorl %eax, %eax
testl %r14d, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: InitLabels
void InitLabels(void)
{
  int c,c1;

  memset((char *) hash, 0, 256*sizeof(label_t *));
  next_local =
    local_labels = (label_t *)my_malloc( sizeof(label_t) * MAX_LOCAL_LABELS );
  next_global =
    global_labels = (label_t *)my_malloc( sizeof(label_t) * MAX_GLOBAL_LABELS );
  next_macro =
    macro_labels = (label_t *)my_malloc( sizeof(label_t) * MAX_MACRO_LABELS );
  next_macroname =
    macronames = (label_t *)my_malloc( sizeof(label_t) * MAX_MACROS);

  memset((char *)LabelTable, FALSE, 256 * sizeof(int) );

  for (c = 'A',c1 = 'a'; c <= 'Z'; c++,c1++){
    LabelTable[ c ] = TRUE;
    LabelTable[ c1 ]= TRUE;
  }
  for (c = '0'; c <= '9'; c++)
    LabelTable[ c ] = TRUE;

  LabelTable[(int)'_'] = TRUE;
  LabelTable[(int)'@'] = TRUE;
  LabelTable[(int)'.'] = TRUE;
}

// Assembly:
pushq %rbx
leaq 0x17454(%rip), %rdi     # 0x1cf70
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x30d0
movl $0xc000, %edi           # imm = 0xC000
callq 0x331c
movq %rax, 0x17c37(%rip)     # 0x1d770
movq %rax, 0x17c38(%rip)     # 0x1d778
movl $0xc0000, %edi          # imm = 0xC0000
callq 0x331c
movq %rax, 0x17c2f(%rip)     # 0x1d780
movq %rax, 0x17c30(%rip)     # 0x1d788
movl $0xc000, %edi           # imm = 0xC000
callq 0x331c
movq %rax, 0x17c27(%rip)     # 0x1d790
movq %rax, 0x17c28(%rip)     # 0x1d798
movl $0x18000, %edi          # imm = 0x18000
callq 0x331c
movq %rax, 0x17c1f(%rip)     # 0x1d7a0
movq %rax, 0x17c20(%rip)     # 0x1d7a8
leaq 0x17c21(%rip), %rbx     # 0x1d7b0
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30d0
movq $-0x1a, %rax
movl $0x1, %ecx
movl %ecx, 0x16c(%rbx,%rax,4)
movl %ecx, 0x1ec(%rbx,%rax,4)
incq %rax
jne 0x5baa
xorl %eax, %eax
movdqa 0x7539(%rip), %xmm0     # 0xd100
movdqa 0x7541(%rip), %xmm1     # 0xd110
movdqa 0x7549(%rip), %xmm2     # 0xd120
movdqa 0x7551(%rip), %xmm3     # 0xd130
pshufd $0xf5, %xmm3, %xmm4     # xmm4 = xmm3[1,1,3,3]
movq %rax, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm1, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm3, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pcmpeqd %xmm4, %xmm6
pand %xmm7, %xmm6
movd %xmm6, %ecx
testb $0x1, %cl
je 0x5c23
movl $0x1, 0xc0(%rbx,%rax,4)
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x5c38
movl $0x1, 0xc4(%rbx,%rax,4)
por %xmm0, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm3, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm4, %xmm5
pand %xmm6, %xmm5
pextrw $0x0, %xmm5, %ecx
testb $0x1, %cl
je 0x5c6a
movl $0x1, 0xc8(%rbx,%rax,4)
pextrw $0x4, %xmm5, %ecx
testb $0x1, %cl
je 0x5c7f
movl $0x1, 0xcc(%rbx,%rax,4)
addq $0x4, %rax
cmpq $0xc, %rax
jne 0x5be4
movl $0x1, %eax
movl %eax, 0x17c94(%rip)     # 0x1d92c
movl %eax, 0x17c12(%rip)     # 0x1d8b0
movl %eax, 0x17bc4(%rip)     # 0x1d868
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: ComputeHash
int ComputeHash(char * s)
{
  int hashval = 0;
  int pos = 0;
  while ( *s ){
    hashval ^= pos;
    hashval += (int) *s;
    ++s;
    ++pos;
  }
  return (hashval & 255);
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x5cc8
xorl %ecx, %ecx
xorl %edx, %edx
movl %ecx, %esi
xorl %edx, %esi
movzbl %al, %edx
addl %esi, %edx
movb 0x1(%rdi,%rcx), %al
incq %rcx
testb %al, %al
jne 0x5cb0
movzbl %dl, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: ClearLocals
void ClearLocals()
{
  CheckForUnsolvedLocals();
  next_local = local_labels;
  local_hook = NULL;
  memset((char *)local_labels, 0,  sizeof(label_t)*MAX_LOCAL_LABELS);
}

// Assembly:
pushq %rax
xorl %eax, %eax
callq 0x44e7
movq 0x17a96(%rip), %rdi     # 0x1d770
movq %rdi, 0x17a97(%rip)     # 0x1d778
movq $0x0, 0x17254(%rip) # 0x1cf40
movl $0xc000, %edx           # imm = 0xC000
xorl %esi, %esi
popq %rax
jmp 0x30d0
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: FindLabel
label_t * FindLabel(label_t *l, int32_t *value)
{
  label_t *next;

  if ( l->type & LOCAL ){
    next = local_hook;
    if ( l->type & MACRO ){
      next = macro_hook;
    }
  } else {
    next = hash[ComputeHash(l->name)];
  }

  for ( ; next; next = next->next ){

    //  printf("FindLabel:(%s)%p\n",next->name,next->next);

    if ( (l->len == next->len) && !strcmp(l->name,next->name)){
      *value = (int32_t)next->value;
      l->type = next->type;
      if ( next->type & UNSOLVED )
        return 0;
      else
        return next;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
testb $0x2, %al
jne 0x6123
movb 0x38(%rbx), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x6116
xorl %edx, %edx
movl %edx, %esi
xorl %eax, %esi
movzbl %cl, %eax
addl %esi, %eax
movb 0x39(%rbx,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x60ff
movzbl %al, %eax
leaq 0x16e53(%rip), %rcx     # 0x1cf70
leaq (%rcx,%rax,8), %rax
jmp 0x6137
testb $0x4, %al
leaq 0x16e14(%rip), %rcx     # 0x1cf40
leaq 0x16e15(%rip), %rax     # 0x1cf48
cmoveq %rcx, %rax
movq (%rax), %r13
testq %r13, %r13
je 0x6169
movl (%rbx), %ebp
leaq 0x38(%rbx), %r12
xorl %r15d, %r15d
cmpl (%r13), %ebp
jne 0x615e
leaq 0x38(%r13), %rsi
movq %r12, %rdi
callq 0x3110
testl %eax, %eax
je 0x616e
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0x6148
jmp 0x6185
xorl %r15d, %r15d
jmp 0x6185
movl 0x8(%r13), %eax
movl %eax, (%r14)
movl 0x4(%r13), %eax
movl %eax, 0x4(%rbx)
xorl %r15d, %r15d
testb %al, %al
cmovnsq %r13, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: FindMacro
int FindMacro(char *s, label_t ** macro)
{
  label_t *ptr = macroname_hook;

  while ( ptr ){
    if ( ! strcmp(s,ptr->name) ){
      break;
    }
    ptr = ptr->next;
  }
  if ( ! ptr ){
    return 1;
  }

  *macro = ptr;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x16daa(%rip), %r12     # 0x1cf50
movl $0x1, %ebx
testq %r12, %r12
je 0x61d8
movq %rsi, %r14
movq %rdi, %r15
leaq 0x38(%r12), %rsi
movq %r15, %rdi
callq 0x3110
testl %eax, %eax
je 0x61d3
movq 0x28(%r12), %r12
testq %r12, %r12
jne 0x61b6
jmp 0x61d8
movq %r12, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: DumpGlobals
void DumpGlobals()
{
  label_t * next;
  int i;
  fprintf(my_stderr,"Global labels:\n");
  for (i = 0; i < 256; ++i){
    for( next = hash[i] ; next ; next = next->next ){
      if ( !(next->type & UNSOLVED) && (next->type & GLOBAL)){
        if ( Global.mainMode == JAGUAR_DSP || Global.mainMode == JAGUAR_GPU ){
          fprintf(my_stderr,"<%32s> = %016"PRIx64" %02x [%5d %s]\n",
                  next->name, next->value, next->type,
                  next->line, file_list[next->file].name);
        } else {
          fprintf(my_stderr,"<%32s> = %08x %02x [%5d %s]\n",
                  next->name, (uint32_t)next->value, next->type,
                  next->line, file_list[next->file].name);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe3e9(%rip), %r15      # 0x145f8
movq (%r15), %rcx
leaq 0x6f27(%rip), %rdi      # 0xd140
movl $0xf, %esi
movl $0x1, %edx
callq 0x31d0
leaq 0xe181(%rip), %r13      # 0x143b0
leaq 0xe5aa(%rip), %rbp      # 0x147e0
leaq 0x6f32(%rip), %r14      # 0xd16f
xorl %r12d, %r12d
leaq 0x16d29(%rip), %rax     # 0x1cf70
movq (%rax,%r12,8), %rbx
testq %rbx, %rbx
je 0x62db
movl 0x4(%rbx), %r8d
movl %r8d, %eax
andl $0x88, %eax
cmpl $0x8, %eax
jne 0x62d2
movl 0x1c(%r13), %eax
andl $-0x2, %eax
leaq 0x38(%rbx), %rdx
movq (%r15), %rdi
movq 0x8(%rbx), %rcx
cmpl $0x2, %eax
jne 0x62aa
movl 0x10(%rbx), %r9d
movslq 0x14(%rbx), %rax
movq %rax, %rsi
shlq $0x9, %rsi
leaq (%rsi,%rax,4), %rax
addq %rbp, %rax
addq $0x4, %rax
movq %rax, (%rsp)
leaq 0x6eaf(%rip), %rsi      # 0xd150
xorl %eax, %eax
callq 0x3130
jmp 0x62d2
movl 0x10(%rbx), %r9d
movslq 0x14(%rbx), %rax
movq %rax, %rsi
shlq $0x9, %rsi
leaq (%rsi,%rax,4), %rax
addq %rbp, %rax
addq $0x4, %rax
movq %rax, (%rsp)
movq %r14, %rsi
xorl %eax, %eax
callq 0x3130
movq 0x28(%rbx), %rbx
jmp 0x624b
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x6240
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: writeSymbols
void writeSymbols(char *fn, int hex)
{
  label_t * next;
  int i;
  FILE *fh;
  char *help = fn + strlen(fn);

  while ( *help != '.' )
    --help;

  ++help;
  *help = 0;

  help = my_malloc((long)strlen(fn)+4UL);
  strcpy(help,fn);
  strcat(help,"equ");
  if ( (fh = fopen(help,"w")) == NULL ){
    Error(-WRITE_ERR,fn);
    return;
  }

  for (i = 0; i < 256; ++i){
    for( next = hash[i] ; next ; next = next->next ){
      if ( !(next->type & UNSOLVED) && (next->type & GLOBAL)){
        if ( Global.mainMode == JAGUAR_DSP || Global.mainMode == JAGUAR_GPU ){
          if ( hex ){
            fprintf(fh,"%-24s EQU $%016"PRIx64"\n",next->name,next->value);
          } else {
            fprintf(fh,"%-24s EQU %"PRIi64"\n",next->name,next->value);
          }
        } else {
          if ( hex ){
            fprintf(fh,"%-24s EQU $%08x\n",next->name,(uint32_t)next->value);
          } else {
            fprintf(fh,"%-24s EQU %d\n",next->name,(uint32_t)next->value);
          }
        }
      }
    }
  }
  fclose(fh);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
callq 0x30b0
addq %r15, %rax
addq $0x2, %rax
cmpb $0x2e, -0x2(%rax)
leaq -0x1(%rax), %rax
jne 0x6316
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x30b0
leaq 0x4(%rax), %rdi
callq 0x331c
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x3070
movq %r14, %rdi
callq 0x30b0
movl $0x757165, (%r14,%rax)  # imm = 0x757165
leaq 0x6e33(%rip), %rsi      # 0xd18c
movq %r14, %rdi
callq 0x3190
testq %rax, %rax
je 0x640f
movq %rax, %r14
movl $0x88, %r15d
leaq 0xe036(%rip), %r13      # 0x143b0
xorl %r12d, %r12d
leaq 0x16bec(%rip), %rax     # 0x1cf70
movq (%rax,%r12,8), %rbp
testq %rbp, %rbp
je 0x63ed
movl 0x4(%rbp), %eax
andl %r15d, %eax
cmpl $0x8, %eax
jne 0x63e7
movl 0x1c(%r13), %eax
andl $-0x2, %eax
leaq 0x38(%rbp), %rdx
movq 0x8(%rbp), %rcx
movq %r14, %rdi
cmpl $0x2, %eax
jne 0x63bc
testl %ebx, %ebx
je 0x63c9
leaq 0x6dd4(%rip), %rsi      # 0xd18e
jmp 0x63d0
testl %ebx, %ebx
je 0x63d9
leaq 0x6de9(%rip), %rsi      # 0xd1b0
jmp 0x63e0
leaq 0x6dd1(%rip), %rsi      # 0xd1a1
xorl %eax, %eax
callq 0x3130
jmp 0x63e7
leaq 0x6de1(%rip), %rsi      # 0xd1c1
xorl %eax, %eax
callq 0x3130
movq 0x28(%rbp), %rbp
jmp 0x6388
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x637d
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30a0
movl $0xffffffd7, %edi       # imm = 0xFFFFFFD7
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa1d8
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: hashStatistics
void hashStatistics()
{
  int i,total = 0;
  label_t *next;
  for(i = 0 ; i < 256;++i){
    int o = 0;
    for (next = hash[i]; next; next = next->next ){
      ++o;
    }
    total += o;
    printf("%4d ",o);
  }
  printf("\n total:%d\n",total);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x16b37(%rip), %r15     # 0x1cf70
leaq 0x6d8f(%rip), %r14      # 0xd1cf
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r15,%r12,8), %rax
movl $0x0, %esi
testq %rax, %rax
je 0x6460
xorl %esi, %esi
incl %esi
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x6455
addl %esi, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c0
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x6445
leaq 0x6d55(%rip), %rdi      # 0xd1d4
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: DumpLocals
void DumpLocals()
{
  label_t * next = local_labels;
  fprintf(my_stderr,"Local labels:\n");
  for ( ; next ; next = next->next ){
    if ( Global.mainMode == JAGUAR_DSP || Global.mainMode == JAGUAR_GPU ){
      fprintf(my_stderr,"<%32s> = %0"PRIx64" [%5d %s]\n",
              next->name,next->value,next->line,file_list[next->file].name);
    } else {
      fprintf(my_stderr,"<%32s> = %04x [%5d %s]\n",
              next->name,(uint32_t)next->value,
              next->line,file_list[next->file].name);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x172cb(%rip), %r15     # 0x1d770
leaq 0xe14c(%rip), %r12      # 0x145f8
movq (%r12), %rcx
leaq 0x6d29(%rip), %rdi      # 0xd1e0
movl $0xe, %esi
movl $0x1, %edx
callq 0x31d0
testq %r15, %r15
je 0x6558
leaq 0xdeda(%rip), %r13      # 0x143b0
leaq 0xe303(%rip), %rbp      # 0x147e0
leaq 0x6d0b(%rip), %rbx      # 0xd1ef
leaq 0x6d1c(%rip), %r14      # 0xd207
movl 0x1c(%r13), %eax
andl $-0x2, %eax
leaq 0x38(%r15), %rdx
movq (%r12), %rdi
movq 0x8(%r15), %rcx
cmpl $0x2, %eax
jne 0x652a
movl 0x10(%r15), %r8d
movslq 0x14(%r15), %rax
movq %rax, %rsi
shlq $0x9, %rsi
leaq (%rsi,%rax,4), %rax
leaq (%rax,%rbp), %r9
addq $0x4, %r9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3130
jmp 0x654f
movl 0x10(%r15), %r8d
movslq 0x14(%r15), %rax
movq %rax, %rsi
shlq $0x9, %rsi
leaq (%rsi,%rax,4), %rax
leaq (%rax,%rbp), %r9
addq $0x4, %r9
movq %r14, %rsi
xorl %eax, %eax
callq 0x3130
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x64eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: DumpMacros
void DumpMacros()
{
  label_t * next = macroname_hook;
  fprintf(my_stderr,"Macros:\n");
  for ( ; next ; next = next->next ){
    fprintf(my_stderr,"<%32s> [%5d %s]\n",
            next->name,next->line,file_list[next->file].name);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x169da(%rip), %r14     # 0x1cf50
leaq 0xe07b(%rip), %r15      # 0x145f8
movq (%r15), %rcx
leaq 0x6c98(%rip), %rdi      # 0xd21f
movl $0x8, %esi
movl $0x1, %edx
callq 0x31d0
testq %r14, %r14
je 0x65de
leaq 0xe23e(%rip), %r12      # 0x147e0
leaq 0x69ea(%rip), %rbx      # 0xcf93
movq (%r15), %rdi
leaq 0x38(%r14), %rdx
movl 0x10(%r14), %ecx
movslq 0x14(%r14), %rax
movq %rax, %rsi
shlq $0x9, %rsi
leaq (%rsi,%rax,4), %rax
leaq (%r12,%rax), %r8
addq $0x4, %r8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3130
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x65a9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/label.c
// Function: newSymbol
label_t * newSymbol(const char *name, uint64_t value)
{
  label_t label = {0};
  int solved;

  label.value = value;
  label.type = NORMAL;
  strcpy(label.name, name);
  label.len   = strlen(name);
  label.file  = 0;
  label.line  = 0;

  return DefineLabel(&label, &solved);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x48(%rsp), %r14
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movups %xmm0, -0x10(%r14)
movups %xmm0, -0x20(%r14)
xorl %r15d, %r15d
movq %r15, 0x20(%r14)
movq %rsi, -0x30(%r14)
movl $0x1, -0x34(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3070
movq %rbx, %rdi
callq 0x30b0
movl %eax, -0x38(%r14)
movq %r15, -0x28(%r14)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5cf9
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/opcode.c
// Function: SearchOpcode
int SearchOpcode(const struct opcode_s *list, const char *s)
{
  const struct opcode_s *curr;

  if ( strlen(s) > 7 ){
    return -1;
  }
  curr = list;
  while ( curr->name[0] ){
    if ( !strcasecmp(curr->name,s) ){
      //      printf("Found (%s)\n",curr->name);
      return curr->func( curr->misc );
    }
    curr++;
  }
  return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x30b0
cmpq $0x7, %rax
ja 0x6690
cmpb $0x0, (%r14)
je 0x6690
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3060
testl %eax, %eax
je 0x669d
cmpb $0x0, 0x20(%r14)
leaq 0x20(%r14), %r14
jne 0x6676
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rax
movl 0x18(%r14), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/opcode.c
// Function: SearchOpcode2
int SearchOpcode2(const struct opcode_s *list,
                  const char *s,
                  int (**fun)(int ),
                  int *para)
{
  const struct opcode_s *curr;
  extern int mac_mode;

  // ignore leading dot
  if ( s[0] == '.' ){
    ++s;
  }
  if ( strlen(s) > 7 && !mac_mode ){
    return -1;
  }

  if ( Global.mainMode != JAGUAR_GPU &&
       Global.mainMode != JAGUAR_DSP &&
       !strcasecmp(s,"DP") )
    {
      return -1;
    }
  curr = list;

  while ( curr->name[0] ){
    if ( !strcasecmp(curr->name,s) ){
      //      printf("Found (%s)\n",curr->name);
      *fun = curr->func;
      *para = curr->misc;
      return 1;
    }
    curr++;
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpb $0x2e, (%rsi)
sete %r12b
addq %rsi, %r12
movq %r12, %rdi
callq 0x30b0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $0x8, %rax
jb 0x66eb
leaq 0x174ca(%rip), %rax     # 0x1dbb0
cmpl $0x0, (%rax)
je 0x6744
leaq 0xdcbe(%rip), %rax      # 0x143b0
movl 0x1c(%rax), %eax
addl $-0x4, %eax
cmpl $-0x3, %eax
ja 0x6710
leaq 0x6b24(%rip), %rsi      # 0xd228
movq %r12, %rdi
callq 0x3060
testl %eax, %eax
je 0x6744
cmpb $0x0, (%r15)
je 0x6744
movq %r15, %rdi
movq %r12, %rsi
callq 0x3060
testl %eax, %eax
je 0x6732
cmpb $0x0, 0x20(%r15)
leaq 0x20(%r15), %r15
jne 0x6716
jmp 0x6744
movq 0x10(%r15), %rax
movq %rax, (%r14)
movl 0x18(%r15), %eax
movl %eax, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/pseudo.c
// Function: p_org
int p_org(int d)
{
  int32_t l;
  int err;

  if ( (err = NeedConst( &l, "ORG" )) ) return err;

  if ( Global.genesis == 1 && mac_mode == 0){
    if ( (uint32_t)l < Global.pc ) return Error(SYNTAX_ERR,"");
    writeSameBytes( 0, l-Global.pc );
  } else {
    Global.pc = (uint32_t)l;
  }

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x6af4(%rip), %rsi      # 0xd250
leaq 0xc(%rsp), %rdi
callq 0x9de2
movl %eax, %ebx
testl %eax, %eax
jne 0x67ae
leaq 0xdc3d(%rip), %rax      # 0x143b0
cmpl $0x1, 0x14(%rax)
movl 0xc(%rsp), %esi
jne 0x679f
cmpl $0x0, 0x1742c(%rip)     # 0x1dbb0
jne 0x679f
subl (%rax), %esi
jae 0x67a5
leaq 0x6801(%rip), %rsi      # 0xcf92
movl $0x12, %edi
callq 0xa1d8
movl %eax, %ebx
jmp 0x67ae
movl %esi, (%rax)
xorl %ebx, %ebx
jmp 0x67ae
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x3466
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/42Bastian[P]lyxass/pseudo.c
// Function: p_run
int p_run(int d)
{
  int err;
  int32_t l;

  KillSpace();
  if ( !atom ) {
    l = Global.pc;
  } else {
    if ( (err = NeedConst( &l, "RUN" )) ) return err;
  }
  if ( Global.run == -1){
    Global.mainMode = sourceMode;
    Global.run = l;
    Global.genesis = 1;
  }
  Global.pc = l;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x4ff7
leaq 0x16743(%rip), %rax     # 0x1cf30
leaq 0xdbbc(%rip), %r14      # 0x143b0
cmpl $0x0, (%rax)
movq %r14, %rbx
je 0x6814
leaq 0x6a51(%rip), %rsi      # 0xd254
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0x9de2
testl %eax, %eax
jne 0x6845
movl (%rbx), %eax
cmpl $-0x1, 0x10(%r14)
jne 0x683a
leaq 0xddcc(%rip), %rcx      # 0x145f0
movl (%rcx), %ecx
leaq 0xdb83(%rip), %rdx      # 0x143b0
movl %ecx, 0x1c(%rdx)
movl %eax, 0x10(%rdx)
movl $0x1, 0x14(%rdx)
leaq 0xdb6f(%rip), %rcx      # 0x143b0
movl %eax, (%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq