LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: pqueue_create
PriorityQueue pqueue_create(CompareFunc compare, DestroyFunc destroy_value, Vector values) {
	assert(compare != NULL);	// LCOV_EXCL_LINE

	PriorityQueue pqueue = malloc(sizeof(*pqueue));
	pqueue->compare = compare;
	pqueue->destroy_value = destroy_value;

	// Δημιουργία του vector που αποθηκεύει τα στοιχεία.
	// ΠΡΟΣΟΧΗ: ΔΕΝ περνάμε την destroy_value στο vector!
	// Αν την περάσουμε θα καλείται όταν κάνουμε swap 2 στοιχεία, το οποίο δεν το επιθυμούμε.
	pqueue->values = vector_create(0, NULL);

	// Αν values != NULL, αρχικοποιούμε το σωρό.
	if (values != NULL)
		naive_heapify(pqueue, values);

	return pqueue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x44f5
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
pushq $0x18
popq %rdi
callq 0x21a0
movq %rax, %r14
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
xorl %r15d, %r15d
xorl %edi, %edi
xorl %esi, %esi
callq 0x4718
movq %rax, (%r14)
testq %rbx, %rbx
je 0x44e9
movq %rbx, %rdi
callq 0x4752
movl %eax, %ebp
testl %eax, %eax
cmovlel %r15d, %ebp
cmpl %r15d, %ebp
je 0x44e9
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4756
movq %r14, %rdi
movq %rax, %rsi
callq 0x4529
incl %r15d
jmp 0x44c9
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1956(%rip), %rdi      # 0x5e52
leaq 0x195f(%rip), %rsi      # 0x5e62
leaq 0x1980(%rip), %rcx      # 0x5e8a
pushq $0x6a
popq %rdx
callq 0x2110
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: pqueue_insert
void pqueue_insert(PriorityQueue pqueue, Pointer value) {
	// Προσθέτουμε την τιμή στο τέλος το σωρού
	vector_insert_last(pqueue->values, value);

 	// Ολοι οι κόμβοι ικανοποιούν την ιδιότητα του σωρού εκτός από τον τελευταίο, που μπορεί να είναι
	// μεγαλύτερος από τον πατέρα του. Αρα μπορούμε να επαναφέρουμε την ιδιότητα του σωρού καλώντας
	// τη bubble_up γα τον τελευταίο κόμβο (του οποίου το 1-based id ισούται με το νέο μέγεθος του σωρού).
	bubble_up(pqueue, pqueue_size(pqueue));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x47df
movq %rbx, %rdi
callq 0x4512
movl %eax, %ebp
pushq $0x2
popq %r12
cmpl $0x1, %ebp
je 0x4595
movl %ebp, %eax
cltd
idivl %r12d
movl %eax, %r14d
movq 0x8(%rbx), %r13
movq %rbx, %rdi
movl %eax, %esi
callq 0x451f
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x451f
movq %r15, %rdi
movq %rax, %rsi
callq *%r13
testl %eax, %eax
jns 0x4595
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x46a6
movl %r14d, %ebp
jmp 0x454d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: pqueue_remove_max
void pqueue_remove_max(PriorityQueue pqueue) {
	int last_node = pqueue_size(pqueue);
	assert(last_node != 0);		// LCOV_EXCL_LINE

	// Destroy την τιμή που αφαιρείται
	if (pqueue->destroy_value != NULL)
		pqueue->destroy_value(pqueue_max(pqueue));

	// Αντικαθιστούμε τον πρώτο κόμβο με τον τελευταίο και αφαιρούμε τον τελευταίο
	node_swap(pqueue, 1, last_node);
	vector_remove_last(pqueue->values);

 	// Ολοι οι κόμβοι ικανοποιούν την ιδιότητα του σωρού εκτός από τη νέα ρίζα
 	// που μπορεί να είναι μικρότερη από κάποιο παιδί της. Αρα μπορούμε να
 	// επαναφέρουμε την ιδιότητα του σωρού καλώντας τη bubble_down για τη ρίζα.
	bubble_down(pqueue, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4512
testl %eax, %eax
je 0x4687
movl %eax, %ebp
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x45d8
movq %rbx, %rdi
callq 0x451a
movq %rax, %rdi
callq *%r14
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x46a6
movq (%rbx), %rdi
callq 0x4823
leal (%r14,%r14), %ebp
movq %rbx, %rdi
callq 0x4512
cmpl %eax, %ebp
jg 0x4678
jge 0x463a
leal 0x1(,%r14,2), %r15d
movq 0x8(%rbx), %r13
movq %rbx, %rdi
movl %ebp, %esi
callq 0x451f
movq %rax, %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x451f
movq %r12, %rdi
movq %rax, %rsi
callq *%r13
testl %eax, %eax
js 0x4637
movl %ebp, %r15d
movl %r15d, %ebp
movq 0x8(%rbx), %r12
movq %rbx, %rdi
movl %r14d, %esi
callq 0x451f
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x451f
movq %r15, %rdi
movq %rax, %rsi
callq *%r12
testl %eax, %eax
jns 0x4678
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x46a6
movl %ebp, %r14d
jmp 0x45f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x183a(%rip), %rdi      # 0x5ec8
leaq 0x17cd(%rip), %rsi      # 0x5e62
leaq 0x183b(%rip), %rcx      # 0x5ed7
movl $0x90, %edx
callq 0x2110
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: node_swap
static void node_swap(PriorityQueue pqueue, int node_id1, int node_id2) {
	// τα node_ids είναι 1-based, το node_id αποθηκεύεται στη θέση node_id - 1
	Pointer value1 = node_value(pqueue, node_id1);
	Pointer value2 = node_value(pqueue, node_id2);

	vector_set_at(pqueue->values, node_id1 - 1, value2);
	vector_set_at(pqueue->values, node_id2 - 1, value1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x451f
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x451f
movq (%r14), %rdi
decl %ebp
movl %ebp, %esi
movq %rax, %rdx
callq 0x4787
movq (%r14), %rdi
decl %ebx
movl %ebx, %esi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4787
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: pqueue_destroy
void pqueue_destroy(PriorityQueue pqueue) {
	// Αντί να κάνουμε εμείς destroy τα στοιχεία, είναι απλούστερο να
	// προσθέσουμε τη destroy_value στο vector ώστε να κληθεί κατά το vector_destroy.
	vector_set_destroy_value(pqueue->values, pqueue->destroy_value);
	vector_destroy(pqueue->values);

	free(pqueue);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rbx), %rsi
callq 0x48e5
movq (%rbx), %rdi
callq 0x48ee
movq %rbx, %rdi
popq %rbx
jmp 0x22b0
// File: /workspace/github_c_makefile_star2_O2/umbrant[P]Non-blocking-Buffers/nameserver_main.c
// Function: main
int main() 
{
	if(init_nameserver()) {
		printf("Error initializing nameserver, failing!\n");
		return -1;
	}

  signal(SIGUSR1, data_available);

	while(1) {
    sleep(1);
	}
}

// Assembly:
pushq %rbx
xorl %eax, %eax
callq 0x18f2
testl %eax, %eax
je 0x1369
leaq 0x1ca5(%rip), %rdi      # 0x3004
callq 0x1070
pushq $-0x1
popq %rax
popq %rbx
retq
leaq 0x1284(%rip), %rsi      # 0x25f4
pushq $0xa
popq %rdi
callq 0x1150
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x1240
jmp 0x137b
// File: /workspace/github_c_makefile_star2_O2/umbrant[P]Non-blocking-Buffers/nameserver.c
// Function: data_available
void data_available(int signum)
{
	char* recv;
  size_t recv_len;
	int retval = -1;
  int request_type;

	retval = nbb_read_item(CHANNEL_ID, (void**)&recv, &recv_len);

	// This is kind of a hack
	// Do an extra resize and copy to null terminate
	char* recv_str = (char*)calloc(recv_len+1, sizeof(char));
	memcpy(recv_str, recv, recv_len);
	recv_str[recv_len] = '\0';
 
printf("nameserver recv: %s\n", recv_str);

  request_type = atoi(strtok(recv_str, " "));
  handle_connection[request_type](strtok(NULL, ""));

  signal(SIGUSR1, data_available);
  free(recv);
  free(recv_str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x17ea
movq (%r14), %r15
leaq 0x1(%r15), %rdi
pushq $0x1
popq %rsi
callq 0x1100
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x1140
movb $0x0, (%r14,%r15)
leaq 0x136f(%rip), %rdi      # 0x39b1
movq %r14, %rsi
xorl %eax, %eax
callq 0x10c0
leaq 0xaf2(%rip), %rsi       # 0x3145
movq %r14, %rdi
callq 0x11e0
movq %rax, %rdi
callq 0x1210
movslq %eax, %r15
leaq 0x3773(%rip), %r12      # 0x5de0
leaq 0xd6a(%rip), %rsi       # 0x33de
xorl %edi, %edi
callq 0x11e0
movq %rax, %rdi
callq *(%r12,%r15,8)
leaq -0x95(%rip), %rsi       # 0x25f4
pushq $0xa
popq %rdi
callq 0x1150
movq (%rbx), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/umbrant[P]Non-blocking-Buffers/nameserver.c
// Function: handle_client
void handle_client(char* arg)
{
  printf("\n** Handling client\n");

  char* msg = (char*)malloc(50*sizeof(char));
  int service_id;
  int channel_id; 

  service_id = find_service(arg);

  if(service_id == -1) {
    printf("** Unable to find service: %s\n", arg);
    strcpy(msg, UNKNOWN_SERVICE);

    nbb_insert_item(CHANNEL_ID, msg, strlen(msg));
    free(msg);
    return;
  }

  printf("** Able to find service: %s\n", arg);

  channel_id = bind_client_service(service_id);
  if(channel_id == -1) {
    printf("** Service has no channel free\n");
    strcpy(msg, SERVICE_BUSY);

    nbb_insert_item(CHANNEL_ID, msg, strlen(msg));
    free(msg);
    return;
  }

  printf("** Service could accept connection\n");

  char tmp[2]; 
  sprintf(tmp, "%d", service_lists[service_id].pid); 

  sprintf(msg, "%d", channel_id);
  strcat(msg, " "); 
  strcat(msg, tmp);

  nbb_insert_item(CHANNEL_ID, msg, strlen(msg));
  free(msg);
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x13a7(%rip), %rdi      # 0x3a6a
callq 0x1070
pushq $0x32
popq %rdi
callq 0x1170
movq %rax, %rbx
movq %r14, %rdi
callq 0x27cc
cmpl $-0x1, %eax
je 0x276c
movl %eax, %ebp
leaq 0x12f8(%rip), %rdi      # 0x39e5
movq %r14, %rsi
xorl %eax, %eax
callq 0x10c0
movl %ebp, %edi
callq 0x281c
cmpl $-0x1, %eax
je 0x2789
movl %eax, %r14d
leaq 0x136d(%rip), %rdi      # 0x3a7e
callq 0x1070
movslq %ebp, %rax
imulq $0x28, %rax, %rax
leaq 0x41cc(%rip), %rcx      # 0x68f0
movl 0x1c(%rax,%rcx), %edx
leaq 0x971(%rip), %r15       # 0x30a0
leaq 0xe(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1230
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1230
movq %rbx, %rdi
callq 0x10b0
movw $0x20, (%rbx,%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1220
jmp 0x27a3
leaq 0x1253(%rip), %rdi      # 0x39c6
movq %r14, %rsi
xorl %eax, %eax
callq 0x10c0
movaps 0x135c(%rip), %xmm0     # 0x3ae0
movups %xmm0, (%rbx)
jmp 0x27a3
leaq 0x1311(%rip), %rdi      # 0x3aa1
callq 0x1070
movaps 0x1354(%rip), %xmm0     # 0x3af0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x10b0
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x163d
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/umbrant[P]Non-blocking-Buffers/nameserver.c
// Function: bind_client_service
int bind_client_service(int service_id)
{
  int i;

  for(i = 0;i < service_lists[service_id].num_channels;i++) {
    if(!service_lists[service_id].is_channel_busy[i]) {
      service_lists[service_id].is_channel_busy[i] = 1;
      return service_lists[service_id].channel_ids[i];
    }
  }

  return -1;
}

// Assembly:
movslq %edi, %rax
imulq $0x28, %rax, %rax
leaq 0x40c6(%rip), %rdx      # 0x68f0
leaq (%rdx,%rax), %rcx
movl 0x18(%rax,%rdx), %edx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
pushq $-0x1
popq %rax
cmpq %rsi, %rdx
je 0x2864
movq 0x10(%rcx), %r8
leaq 0x1(%rsi), %rdi
cmpl $0x0, (%r8,%rsi,4)
movq %rdi, %rsi
jne 0x283c
movl $0x1, -0x4(%r8,%rdi,4)
movq 0x8(%rcx), %rax
movl -0x4(%rax,%rdi,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/umbrant[P]Non-blocking-Buffers/nameserver.c
// Function: reserve_channel
int reserve_channel(int slot)
{
  int i;
  int count = 0;

  for(i = 0;i < TOTAL_CHANNELS;i++) {
    if(free_lists[i] == 0) {
      free_lists[i] = 1;
      service_lists[slot].channel_ids[count] = i + 1; // Since nameserver is bind to id 0 
      count++;
    }

    if(count == service_lists[slot].num_channels) {
      break;
    }
  }
  
  // Couldn't reserve all of the channels requested
  if(count != service_lists[slot].num_channels) {
    dealloc_service(slot);
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rax
movslq %edi, %rax
imulq $0x28, %rax, %rax
leaq 0x3eb7(%rip), %rcx      # 0x68f0
addq %rcx, %rax
addq $0x8, %rax
xorl %ecx, %ecx
leaq 0x3f77(%rip), %rdx      # 0x69c0
xorl %esi, %esi
cmpq $0x32, %rcx
je 0x2a79
cmpl $0x0, (%rdx,%rcx,4)
je 0x2a5c
incq %rcx
jmp 0x2a72
movl $0x1, (%rdx,%rcx,4)
incq %rcx
movq (%rax), %r8
movslq %esi, %rsi
movl %ecx, (%r8,%rsi,4)
incl %esi
cmpl 0x10(%rax), %esi
jne 0x2a4b
jmp 0x2a7e
cmpl 0x10(%rax), %esi
jne 0x2a82
xorl %eax, %eax
jmp 0x2a8a
callq 0x2a8c
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x28, %rax, %rax
leaq 0x3e55(%rip), %rcx      # 0x68f0
leaq (%rcx,%rax), %rbx
movl 0x18(%rax,%rcx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
leaq 0x3f0f(%rip), %rdx      # 0x69c0
cmpq %rcx, %rax
je 0x2ac7
movq 0x8(%rbx), %rsi
movslq (%rsi,%rcx,4), %rsi
andl $0x0, (%rdx,%rsi,4)
incq %rcx
jmp 0x2ab1
andl $0x0, 0x20(%rbx)
movq (%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/umbrant[P]Non-blocking-Buffers/nameserver.c
// Function: reserve_service_slot
int reserve_service_slot()
{
  int i;

  for(i = 0;i < NUM_SERVICES;i++) {
    if(!service_lists[i].is_use) {
      service_lists[i].is_use = 1;
      return i;
    }
  }

  return -1;
}

// Assembly:
leaq 0x3e2c(%rip), %rdx      # 0x6910
xorl %ecx, %ecx
pushq $-0x1
popq %rax
cmpq $0x5, %rcx
je 0x2b05
cmpl $0x0, (%rdx)
je 0x2afd
incq %rcx
addq $0x28, %rdx
jmp 0x2ae9
movl $0x1, (%rdx)
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/dropletzhu[P]msuite/tcpserver.c
// Function: echo_server
void echo_server(int socket_fd)
{
	int result;
	char buffer[512];

	memset(buffer, 0, 512);

	result = recv(socket_fd, buffer, 512, 0);
	printf("recv %d\n", result);

	result = send(socket_fd, buffer, 512, 0);
	printf("send %d\n", result);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %edi, %ebx
movq %rsp, %r14
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1030
leaq 0xd24(%rip), %rdi       # 0x2004
movl %eax, %esi
xorl %eax, %eax
callq 0x10a0
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1090
leaq 0xd0c(%rip), %rdi       # 0x200d
movl %eax, %esi
xorl %eax, %eax
callq 0x10a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x40
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movslq %eax, %r13
shll $0x6, %eax
movl %edi, %ecx
subl %eax, %ecx
pushq $0x1
popq %r12
shlq %cl, %r12
leal 0x1(%rbx), %ebp
movq %rsp, %r14
leaq 0x80(%rsp), %r15
xorl %ecx, %ecx
cmpq $0x10, %rcx
jne 0x139e
orq %r12, (%rsp,%r13,8)
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10e0
cmpl $-0x1, %eax
je 0x13a8
movl $0x0, %ecx
testl %eax, %eax
jle 0x13b9
testq %r12, (%rsp,%r13,8)
je 0x1351
movl $0x800, %edx            # imm = 0x800
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x1030
testl %eax, %eax
jg 0x1380
movl $0x0, %ecx
jns 0x1351
jmp 0x13bd
andq $0x0, (%rsp,%rcx,8)
incq %rcx
jmp 0x1351
callq 0x1040
cmpl $0x4, (%rax)
movl $0x0, %ecx
je 0x1351
jmp 0x13e4
jns 0x1351
jmp 0x13df
callq 0x1040
movl (%rax), %edi
callq 0x1160
leaq 0xc46(%rip), %rdi       # 0x2016
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
jmp 0x134f
callq 0x1040
movl (%rax), %edi
callq 0x1160
leaq 0xc39(%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_O2/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 0x3309
addq %r14, 0x110a1(%rip)     # 0x143a8
jmp 0x3318
leaq 0x8c82(%rip), %rsi      # 0xbf92
pushq $-0x6
popq %rdi
callq 0x96cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x1109a(%rip)     # 0x143c4
jle 0x3372
cmpq $0x200000, 0x112a1(%rip) # imm = 0x200000
jl 0x3356
pushq %rax
leaq 0x8c51(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x11074(%rip)    # 0x143c4
addq $0x8, %rsp
jmp 0x3372
movq 0x11283(%rip), %rax     # 0x145e0
leaq 0x1(%rax), %rcx
movq %rcx, 0x11278(%rip)     # 0x145e0
movb %dil, (%rax)
incq 0x11266(%rip)           # 0x145d8
incl 0x11038(%rip)           # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x11044(%rip)     # 0x143c4
jle 0x33c8
cmpq $0x200000, 0x1124b(%rip) # imm = 0x200000
jl 0x33ac
pushq %rax
leaq 0x8bfb(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x1101e(%rip)    # 0x143c4
addq $0x8, %rsp
jmp 0x33c8
movq 0x1122d(%rip), %rax     # 0x145e0
leaq 0x1(%rax), %rcx
movq %rcx, 0x11222(%rip)     # 0x145e0
movb %dil, (%rax)
incq 0x11210(%rip)           # 0x145d8
incl 0x10fe2(%rip)           # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10f95(%rip)     # 0x143c4
jle 0x3484
movslq %ebx, %rax
movq 0x1119d(%rip), %rcx     # 0x145d8
addq %rax, %rcx
cmpq $0x200001, %rcx         # imm = 0x200001
jl 0x345f
leaq 0x8b44(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x10f67(%rip)    # 0x143c4
jmp 0x3484
movl %ebx, %ecx
subl $0x1, %ecx
jb 0x347d
movq 0x11173(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x11168(%rip)     # 0x145e0
movb %dil, (%rdx)
jmp 0x3461
addq %rax, 0x11154(%rip)     # 0x145d8
addl %ebx, 0x10f26(%rip)     # 0x143b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10f2e(%rip)     # 0x143c4
jle 0x34f3
movslq %ebx, %rax
movq 0x11136(%rip), %rcx     # 0x145d8
addq %rax, %rcx
cmpq $0x200001, %rcx         # imm = 0x200001
jl 0x34c6
leaq 0x8add(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x10f00(%rip)    # 0x143c4
jmp 0x34f3
movl %ebx, %ecx
xorl %edx, %edx
cmpl %edx, %ecx
je 0x34ec
movb (%rdi,%rdx), %sil
movq 0x11107(%rip), %r8      # 0x145e0
leaq 0x1(%r8), %r9
movq %r9, 0x110fc(%rip)      # 0x145e0
movb %sil, (%r8)
incq %rdx
jmp 0x34ca
addq %rax, 0x110e5(%rip)     # 0x145d8
addl %ebx, 0x10eb7(%rip)     # 0x143b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10ec2(%rip)     # 0x143c4
jle 0x3560
cmpq $0x1fffff, 0x110c9(%rip) # imm = 0x1FFFFF
jl 0x352e
pushq %rax
leaq 0x8a79(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x10e9c(%rip)    # 0x143c4
addq $0x8, %rsp
jmp 0x3560
movl %edi, %eax
movq 0x110a9(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1109e(%rip)     # 0x145e0
movb %al, (%rcx)
movq 0x11095(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1108a(%rip)     # 0x145e0
movb %ah, (%rcx)
addq $0x2, 0x11078(%rip)     # 0x145d8
addl $0x2, 0x10e49(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10e55(%rip)     # 0x143c4
jle 0x35cd
cmpq $0x1fffff, 0x1105c(%rip) # imm = 0x1FFFFF
jl 0x359b
pushq %rax
leaq 0x8a0c(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x10e2f(%rip)    # 0x143c4
addq $0x8, %rsp
jmp 0x35cd
movl %edi, %eax
movq 0x1103c(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x11031(%rip)     # 0x145e0
movb %ah, (%rcx)
movq 0x11028(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1101d(%rip)     # 0x145e0
movb %al, (%rcx)
addq $0x2, 0x1100b(%rip)     # 0x145d8
addl $0x2, 0x10ddc(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10de8(%rip)     # 0x143c4
jle 0x366e
cmpq $0x1ffffd, 0x10feb(%rip) # imm = 0x1FFFFD
jl 0x360c
pushq %rax
leaq 0x899b(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x10dbe(%rip)    # 0x143c4
addq $0x8, %rsp
jmp 0x366e
movl %edi, %eax
movq 0x10fcb(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10fc0(%rip)     # 0x145e0
movb %al, (%rcx)
movq 0x10fb7(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10fac(%rip)     # 0x145e0
movb %ah, (%rcx)
movl %edi, %ecx
shrl $0x10, %ecx
movq 0x10f9e(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10f93(%rip)     # 0x145e0
movb %cl, (%rdx)
shrl $0x18, %eax
movq 0x10f87(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10f7c(%rip)     # 0x145e0
movb %al, (%rcx)
addq $0x4, 0x10f6a(%rip)     # 0x145d8
addl $0x4, 0x10d3b(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10ca4(%rip)     # 0x143c4
jle 0x3821
cmpq $0x1ffffd, 0x10ea7(%rip) # imm = 0x1FFFFD
jl 0x3753
pushq %rax
leaq 0x8857(%rip), %rsi      # 0xbf92
pushq $0x15
popq %rdi
callq 0x96cc
orl $-0x1, 0x10c7a(%rip)    # 0x143c4
addq $0x8, %rsp
jmp 0x3821
movq %rdi, %rax
movq 0x10e83(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10e78(%rip)     # 0x145e0
movb %al, (%rcx)
movq 0x10e6f(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10e64(%rip)     # 0x145e0
movb %ah, (%rcx)
movl %eax, %ecx
shrl $0x10, %ecx
movq 0x10e56(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10e4b(%rip)     # 0x145e0
movb %cl, (%rdx)
movl %eax, %ecx
shrl $0x18, %ecx
movq 0x10e3d(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10e32(%rip)     # 0x145e0
movb %cl, (%rdx)
movq %rdi, %rcx
shrq $0x20, %rcx
movq 0x10e22(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10e17(%rip)     # 0x145e0
movb %cl, (%rdx)
movq %rdi, %rcx
shrq $0x28, %rcx
movq 0x10e07(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10dfc(%rip)     # 0x145e0
movb %cl, (%rdx)
movq %rdi, %rcx
shrq $0x30, %rcx
movq 0x10dec(%rip), %rdx     # 0x145e0
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10de1(%rip)     # 0x145e0
movb %cl, (%rdx)
shrq $0x38, %rax
movq 0x10dd4(%rip), %rcx     # 0x145e0
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10dc9(%rip)     # 0x145e0
movb %al, (%rcx)
addq $0x8, 0x10db7(%rip)     # 0x145d8
addl $0x4, 0x10b88(%rip)     # 0x143b0
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %rcx, %rdi
callq 0x393c
leaq 0x774c(%rip), %rsi      # 0xb0c8
movq %rbp, %rdi
callq 0x3190
testq %rax, %rax
je 0x39cb
movq %rax, %r12
testq %r13, %r13
je 0x399e
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3170
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x3090
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x30a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x2
popq %rdi
movq %rbp, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x96cc
// File: /workspace/github_c_makefile_star2_O2/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 0x1e981(%rip), %r12     # 0x22da0
movq (%r12), %r13
testq %r13, %r13
je 0x44df
xorl %eax, %eax
leaq 0x103ab(%rip), %r14     # 0x147e0
leaq 0x7b57(%rip), %rbx      # 0xbf93
leaq 0x1e965(%rip), %rbp     # 0x22da8
testq %r13, %r13
je 0x44df
movq %r13, %r15
movq (%r13), %r13
movq 0x38(%r15), %rsi
movl 0x4(%rsi), %ecx
andl $0x6, %ecx
cmpl $0x2, %ecx
jne 0x4443
testb $0x1, %al
jne 0x4479
pushq $0x1d
popq %rdi
leaq 0x7bc4(%rip), %rsi      # 0xc034
callq 0x96cc
movq 0x38(%r15), %rsi
addq $0x38, %rsi
movl 0x14(%r15), %edx
incl %edx
movslq 0x18(%r15), %rax
imulq $0x204, %rax, %rax      # imm = 0x204
leaq (%rax,%r14), %rcx
addq $0x4, %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c0
movq (%r15), %rax
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x44af
movq %rax, (%rcx)
testq %rax, %rax
je 0x44b8
movq %rcx, 0x8(%rax)
cmpq (%r12), %r15
jne 0x44c2
movq %rax, (%r12)
cmpq (%rbp), %r15
jne 0x44d0
movq 0x8(%r15), %rax
movq %rax, (%rbp)
movq %r15, %rdi
callq 0x3050
movb $0x1, %al
jmp 0x4443
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7712
testl %eax, %eax
jns 0x4745
xorl %eax, %eax
cmpl $0x0, 0xff09(%rip)      # 0x14614
jne 0x4745
movq %r14, %rdi
callq 0x89ee
testl %eax, %eax
jns 0x4745
movq %r14, %rdi
callq 0x94aa
testl %eax, %eax
setne %cl
testl %ebx, %ebx
sete %dl
orb %cl, %dl
jne 0x4745
leaq 0x785c(%rip), %rsi      # 0xbf92
pushq $0x12
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x96cc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0xfbe4(%rip), %rax      # 0x14608
movq 0x198(%rax), %rsi
testq %rsi, %rsi
je 0x4a73
leaq 0x1(%rsi), %rcx
movq %rcx, 0x198(%rax)
movzbl (%rsi), %edx
movsbl %dl, %ecx
movl %ecx, 0x183c9(%rip)     # 0x1ce10
movsbl 0x1(%rsi), %esi
movl %esi, 0x183c3(%rip)     # 0x1ce14
cmpl $0xff, %edx
je 0x4a7a
cmpl $0x9, %edx
je 0x4a8d
cmpl $0xa, %edx
je 0x4a9b
cmpl $0xd, %edx
je 0x4a8d
cmpl $0x20, %edx
je 0x4a8d
testl %edx, %edx
je 0x4a7a
jmp 0x4aa8
orl $-0x1, 0x1839a(%rip)    # 0x1ce14
orl $-0x1, 0x1838f(%rip)    # 0x1ce10
andq $0x0, 0x198(%rax)
pushq $-0x1
jmp 0x4aa7
movl $0x20, 0x18379(%rip)    # 0x1ce10
pushq $0x20
jmp 0x4aa7
movl $0xfffffffe, 0x1836b(%rip) # imm = 0xFFFFFFFE
pushq $-0x2
popq %rcx
xorl %eax, %eax
cmpl $-0x2, %ecx
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfb4d(%rip), %rcx      # 0x14608
movslq 0x8(%rcx), %rcx
imulq $0x500, %rcx, %rcx      # imm = 0x500
movslq %esi, %rdx
imulq $0x50, %rdx, %rdx
addq 0xe514(%rip), %rcx      # 0x12fe8
addq %rdx, %rcx
addq $-0x500, %rcx           # imm = 0xFB00
movb (%rcx), %dl
testb %dl, %dl
je 0x4aee
incq %rcx
movb %dl, (%rax)
incq %rax
jmp 0x4ade
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x181e6(%rip), %eax     # 0x1cf30
movl %eax, 0x181e4(%rip)     # 0x1cf34
movq 0x181c9(%rip), %rcx     # 0x1cf20
leaq 0x1(%rcx), %rax
movq %rax, 0x181be(%rip)     # 0x1cf20
movsbl (%rcx), %eax
movl %eax, 0x181c5(%rip)     # 0x1cf30
movsbl 0x1(%rcx), %edx
movl %edx, 0x181c3(%rip)     # 0x1cf38
testl %eax, %eax
je 0x4d7a
retq
movq %rcx, 0x1819f(%rip)     # 0x1cf20
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x18118(%rip), %eax     # 0x1cf30
testl %eax, %eax
je 0x4e2d
cmpl %ebx, %eax
je 0x4e2d
movb %al, (%r14)
incq %r14
callq 0x4d44
jmp 0x4e12
movb $0x0, (%r14)
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4da7
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
callq 0x4dc3
movl 0x180cb(%rip), %ebp     # 0x1cf30
cmpl $0x22, %ebp
je 0x4e7b
cmpl $0x27, %ebp
je 0x4e7b
cmpl $0x3c, %ebp
jne 0x4f6f
pushq $0x3e
popq %rbp
callq 0x4d44
movsbl %bpl, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4e09
testl %eax, %eax
je 0x4f6f
leaq 0x17c52(%rip), %rdi     # 0x1caf0
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x30d0
movl %ebp, %ecx
xorl $0x3e, %ecx
leaq 0xf912(%rip), %rax      # 0x147c8
movq (%rax), %rsi
testq %rsi, %rsi
setne %dl
leaq 0xf72a(%rip), %rax      # 0x145f0
movl (%rax), %eax
movl %eax, %edi
xorl $0x1, %edi
orl %ecx, %edi
sete %cl
testb %dl, %cl
jne 0x4f06
leaq 0xf8f3(%rip), %rcx      # 0x147d0
movq (%rcx), %rcx
andl $-0x2, %eax
leaq 0xf4c6(%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 0x17be3(%rip), %r14     # 0x1caf0
movq %r14, %rdi
callq 0x3070
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x4f4e
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
sarq $0x20, %rcx
movzbl (%r14,%rcx), %ecx
cmpl $0x2f, %ecx
je 0x4f4e
cmpl $0x5c, %ecx
je 0x4f4e
sarq $0x20, %rax
movb $0x2f, (%r14,%rax)
cmpl $0x27, %ebp
jne 0x4f86
movsbq (%rbx), %r14
testq %r14, %r14
je 0x4f86
callq 0x3030
movq (%rax), %rax
movb (%rax,%r14,4), %al
movb %al, (%rbx)
incq %rbx
jmp 0x4f53
leaq 0x701c(%rip), %rsi      # 0xbf92
pushq $0x12
popq %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x96cc
leaq 0x17b63(%rip), %rdi     # 0x1caf0
movq %rsp, %rsi
callq 0x31a0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorps %xmm0, %xmm0
leaq 0xf270(%rip), %rbx      # 0x14608
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
andl $0x0, 0xe0(%rbx)
callq 0x4dc3
xorl %r14d, %r14d
testl %eax, %eax
je 0x5437
callq 0x31e0
movq (%rax), %rcx
movslq 0x17b53(%rip), %rax     # 0x1cf30
movzwl (%rcx,%rax,2), %ecx
btl $0xa, %ecx
jb 0x53f1
cmpl $0x5f, %eax
je 0x53f1
cmpl $0x2e, %eax
jne 0x5440
movl $0x95, %ecx
addq 0xdbd3(%rip), %rcx      # 0x12fd0
pushq $0x1
popq %rdx
leaq 0x183a9(%rip), %r12     # 0x1d7b0
movl %edx, %r14d
movq %rcx, %r15
movb %al, -0x1(%rcx)
callq 0x4d44
testl %eax, %eax
je 0x544d
movslq 0x17b10(%rip), %rax     # 0x1cf30
leal 0x1(%r14), %edx
leaq 0x1(%r15), %rcx
cmpq $0x2e, %rax
je 0x5407
cmpl $0x0, (%r12,%rax,4)
jne 0x5407
jmp 0x544d
leaq 0x94(%rbx), %r15
jmp 0x544d
movl $0x94, %r15d
addq 0xdb83(%rip), %r15      # 0x12fd0
movl %r14d, 0x90(%rbx)
movb $0x0, (%r15)
xorl %eax, %eax
testl %r14d, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17a84(%rip), %rdi     # 0x1cf70
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x30d0
movl $0xc000, %edi           # imm = 0xC000
callq 0x32ec
movq %rax, 0x18267(%rip)     # 0x1d770
movq %rax, 0x18268(%rip)     # 0x1d778
movl $0xc0000, %edi          # imm = 0xC0000
callq 0x32ec
movq %rax, 0x1825f(%rip)     # 0x1d780
movq %rax, 0x18260(%rip)     # 0x1d788
movl $0xc000, %edi           # imm = 0xC000
callq 0x32ec
movq %rax, 0x18257(%rip)     # 0x1d790
movq %rax, 0x18258(%rip)     # 0x1d798
movl $0x18000, %edi          # imm = 0x18000
callq 0x32ec
movq %rax, 0x1824f(%rip)     # 0x1d7a0
movq %rax, 0x18250(%rip)     # 0x1d7a8
leaq 0x18251(%rip), %rbx     # 0x1d7b0
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30d0
pushq $-0x68
popq %rcx
pushq $0x1
popq %rax
testq %rcx, %rcx
je 0x558d
movl %eax, 0x16c(%rcx,%rbx)
movl %eax, 0x1ec(%rcx,%rbx)
addq $0x4, %rcx
jmp 0x5574
xorl %ecx, %ecx
cmpq $0xa, %rcx
je 0x55a5
movl $0x1, 0xc0(%rbx,%rcx,4)
incq %rcx
jmp 0x558f
movl %eax, 0x18381(%rip)     # 0x1d92c
movl %eax, 0x182ff(%rip)     # 0x1d8b0
movl %eax, 0x182b1(%rip)     # 0x1d868
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%rdi,%rax), %edx
testl %edx, %edx
je 0x55ce
xorl %eax, %ecx
addl %edx, %ecx
incq %rax
jmp 0x55bd
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x440d
movq 0x1818f(%rip), %rdi     # 0x1d770
andq $0x0, 0x17957(%rip)     # 0x1cf40
movq %rdi, 0x18188(%rip)     # 0x1d778
movl $0xc000, %edx           # imm = 0xC000
xorl %esi, %esi
popq %rax
jmp 0x30d0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
testb $0x2, %al
jne 0x59ce
leaq 0x38(%rbx), %rdi
callq 0x55b9
movl %eax, %eax
leaq 0x175a8(%rip), %rcx     # 0x1cf70
leaq (%rcx,%rax,8), %r13
jmp 0x59e2
testb $0x4, %al
leaq 0x17569(%rip), %rax     # 0x1cf40
leaq 0x1756a(%rip), %r13     # 0x1cf48
cmoveq %rax, %r13
leaq 0x38(%rbx), %r12
xorl %r15d, %r15d
movq (%r13), %r13
testq %r13, %r13
je 0x5a27
movl (%rbx), %eax
cmpl (%r13), %eax
jne 0x5a0a
leaq 0x38(%r13), %rsi
movq %r12, %rdi
callq 0x3110
testl %eax, %eax
je 0x5a10
addq $0x28, %r13
jmp 0x59e9
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
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %r15
leaq 0x17507(%rip), %r12     # 0x1cf50
pushq $0x1
popq %rbx
movq (%r12), %r12
testq %r12, %r12
je 0x5a71
leaq 0x38(%r12), %rsi
movq %r15, %rdi
callq 0x3110
testl %eax, %eax
je 0x5a6c
addq $0x28, %r12
jmp 0x5a4c
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_O2/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 0xeb4d(%rip), %r15      # 0x145f8
movq (%r15), %rcx
leaq 0x6647(%rip), %rdi      # 0xc0fc
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x31d0
leaq 0xe8e9(%rip), %r13      # 0x143b0
leaq 0xed12(%rip), %rbp      # 0x147e0
leaq 0x6656(%rip), %r14      # 0xc12b
xorl %r12d, %r12d
cmpq $0x100, %r12            # imm = 0x100
je 0x5b7f
leaq 0x17484(%rip), %rax     # 0x1cf70
leaq (%rax,%r12,8), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5b77
movl 0x4(%rbx), %r8d
movl %r8d, %eax
andl $0x88, %eax
cmpl $0x8, %eax
jne 0x5b6e
movl 0x1c(%r13), %eax
andl $-0x2, %eax
leaq 0x38(%rbx), %rdx
movq (%r15), %rdi
movq 0x8(%rbx), %rcx
cmpl $0x2, %eax
jne 0x5b4a
movl 0x10(%rbx), %r9d
movslq 0x14(%rbx), %rax
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rbp, %rax
addq $0x4, %rax
movq %rax, (%rsp)
leaq 0x65cb(%rip), %rsi      # 0xc10c
xorl %eax, %eax
callq 0x3130
jmp 0x5b6e
movl 0x10(%rbx), %r9d
movslq 0x14(%rbx), %rax
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rbp, %rax
addq $0x4, %rax
movq %rax, (%rsp)
movq %r14, %rsi
xorl %eax, %eax
callq 0x3130
addq $0x28, %rbx
jmp 0x5af0
incq %r12
jmp 0x5ad8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5baa
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x30b0
leaq 0x4(%rax), %rdi
callq 0x32ec
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x3070
movq %r14, %rdi
callq 0x30b0
movl $0x757165, (%r14,%rax)  # imm = 0x757165
leaq 0x655b(%rip), %rsi      # 0xc148
movq %r14, %rdi
callq 0x3190
testq %rax, %rax
je 0x5cac
movq %rax, %r14
movl $0x88, %r15d
leaq 0xe7a2(%rip), %r13      # 0x143b0
xorl %r12d, %r12d
cmpq $0x100, %r12            # imm = 0x100
je 0x5c96
leaq 0x1734f(%rip), %rax     # 0x1cf70
leaq (%rax,%r12,8), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x5c8e
movl 0x4(%rbp), %eax
andl %r15d, %eax
cmpl $0x8, %eax
jne 0x5c88
movl 0x1c(%r13), %eax
andl $-0x2, %eax
leaq 0x38(%rbp), %rdx
movq 0x8(%rbp), %rcx
movq %r14, %rdi
cmpl $0x2, %eax
jne 0x5c5d
testl %ebx, %ebx
je 0x5c6a
leaq 0x64ef(%rip), %rsi      # 0xc14a
jmp 0x5c71
testl %ebx, %ebx
je 0x5c7a
leaq 0x6504(%rip), %rsi      # 0xc16c
jmp 0x5c81
leaq 0x64ec(%rip), %rsi      # 0xc15d
xorl %eax, %eax
callq 0x3130
jmp 0x5c88
leaq 0x64fc(%rip), %rsi      # 0xc17d
xorl %eax, %eax
callq 0x3130
addq $0x28, %rbp
jmp 0x5c25
incq %r12
jmp 0x5c11
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30a0
pushq $-0x29
popq %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x96cc