LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: naive_heapify
static void naive_heapify(PriorityQueue pqueue, Vector values) {
	// Απλά κάνουμε insert τα στοιχεία ένα ένα.
	// TODO: υπάρχει πιο αποδοτικός τρόπος να γίνει αυτό!
	int size = vector_size(values);
	for (int i = 0; i < size; i++)
		pqueue_insert(pqueue, vector_get_at(values, i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a80
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5646
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x5aa0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x56c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5613
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: bubble_up
static void bubble_up(PriorityQueue pqueue, int node_id) {
	// Αν φτάσαμε στη ρίζα, σταματάμε
	if (node_id == 1)
		return;

	int parent = node_id / 2;		// Ο πατέρας του κόμβου. Τα node_ids είναι 1-based

	// Αν ο πατέρας έχει μικρότερη τιμή από τον κόμβο, swap και συνεχίζουμε αναδρομικά προς τα πάνω
	if (pqueue->compare(node_value(pqueue, parent), node_value(pqueue, node_id)) < 0) {
		node_swap(pqueue, parent, node_id);
		bubble_up(pqueue, parent);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x5727
jmp 0x578a
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5690
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5690
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rax
callq *%rax
cmpl $0x0, %eax
jge 0x578a
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x5830
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5710
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5650
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x57b0
jmp 0x57cf
leaq 0x16f3(%rip), %rdi      # 0x6eaa
leaq 0x1686(%rip), %rsi      # 0x6e44
movl $0x90, %edx
leaq 0x16ef(%rip), %rcx      # 0x6eb9
callq 0x20f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x57f8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5670
movq %rax, %rdi
movq -0x18(%rbp), %rax
callq *%rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x1, %esi
callq 0x5830
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5c20
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x58a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5690
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5690
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movq -0x20(%rbp), %rdx
callq 0x5b00
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x10(%rbp), %esi
subl $0x1, %esi
movq -0x18(%rbp), %rdx
callq 0x5b00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: bubble_down
static void bubble_down(PriorityQueue pqueue, int node_id) {
	// βρίσκουμε τα παιδιά του κόμβου (αν δεν υπάρχουν σταματάμε)
	int left_child = 2 * node_id;
	int right_child = left_child + 1;

	int size = pqueue_size(pqueue);
	if (left_child > size)
		return;

	// βρίσκουμε το μέγιστο από τα 2 παιδιά
	int max_child = left_child;
	if (right_child <= size && pqueue->compare(node_value(pqueue, left_child), node_value(pqueue, right_child)) < 0)
			max_child = right_child;

	// Αν ο κόμβος είναι μικρότερος από το μέγιστο παιδί, swap και συνεχίζουμε προς τα κάτω
	if (pqueue->compare(node_value(pqueue, node_id), node_value(pqueue, max_child)) < 0) {
		node_swap(pqueue, node_id, max_child);
		bubble_down(pqueue, max_child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5650
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x58d9
jmp 0x597c
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x5927
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5690
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5690
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rax
callq *%rax
cmpl $0x0, %eax
jge 0x5927
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5690
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5690
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x38(%rbp), %rax
callq *%rax
cmpl $0x0, %eax
jge 0x597c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x5830
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x58a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5d80
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5db0
movq -0x8(%rbp), %rdi
callq 0x2280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movb $0x0, %al
callq 0x1de0
cmpl $0x0, %eax
je 0x1374
leaq 0x2ca2(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x10b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
movl $0xa, %edi
leaq 0x1d80(%rip), %rsi      # 0x3100
callq 0x1150
movl $0x1, %edi
callq 0x1230
jmp 0x1385
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
xorl %edi, %edi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1bc0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x1100
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1140
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rsi
leaq 0x18bf(%rip), %rdi      # 0x4a21
movb $0x0, %al
callq 0x10b0
movq -0x28(%rbp), %rdi
leaq 0xfec(%rip), %rsi       # 0x4160
callq 0x11d0
movq %rax, %rdi
callq 0x1200
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rcx
leaq 0x3fa1(%rip), %rax      # 0x7130
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0xe8a(%rip), %rsi       # 0x402c
callq 0x11d0
movq %rax, %rdi
movq -0x30(%rbp), %rax
callq *%rax
movl $0xa, %edi
leaq -0xbc(%rip), %rsi       # 0x3100
callq 0x1150
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1843(%rip), %rdi      # 0x4a36
movb $0x0, %al
callq 0x10b0
movl $0x32, %edi
callq 0x1170
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3370
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x3269
movq -0x8(%rbp), %rsi
leaq 0x1826(%rip), %rdi      # 0x4a4b
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rdi
leaq 0x1919(%rip), %rsi      # 0x4b50
callq 0x1040
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0x1840
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x3366
movq -0x8(%rbp), %rsi
leaq 0x17f6(%rip), %rdi      # 0x4a6a
movb $0x0, %al
callq 0x10b0
movl -0x14(%rbp), %edi
callq 0x33f0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x32d7
leaq 0x17f4(%rip), %rdi      # 0x4a87
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rdi
leaq 0x18bb(%rip), %rsi      # 0x4b60
callq 0x1040
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0x1840
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x3366
leaq 0x17c9(%rip), %rdi      # 0x4aa7
movb $0x0, %al
callq 0x10b0
leaq -0x1a(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x45fc(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %edx
leaq 0xd9c(%rip), %rsi       # 0x40a1
movb $0x0, %al
callq 0x1220
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0xd87(%rip), %rsi       # 0x40a1
movb $0x0, %al
callq 0x1220
movq -0x10(%rbp), %rdi
leaq 0xe34(%rip), %rsi       # 0x4160
callq 0x1210
movq -0x10(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
callq 0x1210
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0x1840
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nameserver.c
// Function: find_service
int find_service(char* name)
{
  int i;

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

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x33d9
movslq -0x14(%rbp), %rcx
leaq 0x455c(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
je 0x33cc
movslq -0x14(%rbp), %rcx
leaq 0x4544(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x33cc
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x33e0
jmp 0x33ce
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3383
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0x44e4(%rip), %rcx      # 0x78f0
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x348b
movslq -0x8(%rbp), %rcx
leaq 0x44cd(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x347b
movslq -0x8(%rbp), %rcx
leaq 0x44ad(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0x448c(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x3492
jmp 0x347d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x33fe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x32, -0xc(%rbp)
jge 0x37b7
movslq -0xc(%rbp), %rcx
leaq 0x4276(%rip), %rax      # 0x79c0
cmpl $0x0, (%rax,%rcx,4)
jne 0x378e
movslq -0xc(%rbp), %rcx
leaq 0x4265(%rip), %rax      # 0x79c0
movl $0x1, (%rax,%rcx,4)
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq -0x8(%rbp), %rcx
leaq 0x417d(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0x4154(%rip), %rcx      # 0x78f0
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jne 0x37aa
jmp 0x37b7
jmp 0x37ac
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3739
movl -0x10(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0x412b(%rip), %rcx      # 0x78f0
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
je 0x37e2
movl -0x8(%rbp), %edi
callq 0x3800
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37e9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0x40d0(%rip), %rcx      # 0x78f0
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x3863
movslq -0x4(%rbp), %rcx
leaq 0x40b9(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rcx
leaq 0x416f(%rip), %rax      # 0x79c0
movl $0x0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3812
movslq -0x4(%rbp), %rcx
leaq 0x4082(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x20(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x4069(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1030
movslq -0x4(%rbp), %rcx
leaq 0x404f(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x3917
movslq -0x8(%rbp), %rcx
leaq 0x4014(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
jne 0x390a
movslq -0x8(%rbp), %rcx
leaq 0x3ffc(%rip), %rax      # 0x78f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x20(%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x391e
jmp 0x390c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x38cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x10b0
movl -0x4(%rbp), %edi
leaq -0x210(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
xorl %ecx, %ecx
callq 0x1030
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xce0(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x10a0
movl -0x4(%rbp), %edi
leaq -0x210(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
xorl %ecx, %ecx
callq 0x1090
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xcbf(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x10a0
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x8b0, %rsp            # imm = 0x8B0
movl %edi, -0x4(%rbp)
jmp 0x1370
jmp 0x1372
leaq -0x88(%rbp), %rax
movq %rax, -0x8a0(%rbp)
movl $0x0, -0x894(%rbp)
movl -0x894(%rbp), %eax
cmpq $0x10, %rax
jae 0x13bc
movq -0x8a0(%rbp), %rax
movl -0x894(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x894(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x894(%rbp)
jmp 0x138a
jmp 0x13be
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x4(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x88(%rbp,%rax,8), %rcx
movq %rcx, -0x88(%rbp,%rax,8)
movl -0x4(%rbp), %edi
addl $0x1, %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x10e0
movl %eax, -0x8(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x8(%rbp)
movb %al, -0x8a1(%rbp)
jne 0x1434
callq 0x1040
cmpl $0x4, (%rax)
sete %al
movb %al, -0x8a1(%rbp)
movb -0x8a1(%rbp), %al
testb $0x1, %al
jne 0x1370
cmpl $0x0, -0x8(%rbp)
jle 0x14d8
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
cltq
movq -0x88(%rbp,%rax,8), %rax
movq %rax, -0x8b0(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x8b0(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x14d6
jmp 0x1492
movl -0x4(%rbp), %edi
leaq -0x890(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x1030
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jg 0x1492
cmpl $0x0, -0x8(%rbp)
jge 0x14d4
callq 0x1040
movl (%rax), %edi
callq 0x1170
movq %rax, %rsi
leaq 0xb49(%rip), %rdi       # 0x2016
movb $0x0, %al
callq 0x10a0
jmp 0x14d6
jmp 0x14ff
cmpl $0x0, -0x8(%rbp)
jge 0x14fd
callq 0x1040
movl (%rax), %edi
callq 0x1170
movq %rax, %rsi
leaq 0xb37(%rip), %rdi       # 0x202b
movb $0x0, %al
callq 0x10a0
jmp 0x1504
jmp 0x14ff
jmp 0x136e
addq $0x8b0, %rsp            # imm = 0x8B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3150
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x331b
movq -0x10(%rbp), %rax
addq 0x1508e(%rip), %rax     # 0x18398
movq %rax, 0x15087(%rip)     # 0x18398
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3334
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
leaq 0xdd36(%rip), %rsi      # 0x1105d
callq 0xd130
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
cmpl $0x0, 0x1505f(%rip)     # 0x183b4
jle 0x33b5
movq 0x1526a(%rip), %rax     # 0x185c8
addq $0x1, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x3387
movl $0x15, %edi
leaq 0xdce7(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x1502f(%rip) # imm = 0xFFFFFFFF
jmp 0x33b3
movb -0x1(%rbp), %cl
movq 0x1523f(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x15231(%rip)     # 0x185d0
movb %cl, (%rax)
movq 0x15220(%rip), %rax     # 0x185c8
addq $0x1, %rax
movq %rax, 0x15215(%rip)     # 0x185c8
jmp 0x33b5
movl 0x14fe5(%rip), %eax     # 0x183a0
addl $0x1, %eax
movl %eax, 0x14fdc(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, 0x14fcc(%rip)     # 0x183b4
jle 0x3450
movq 0x151d7(%rip), %rax     # 0x185c8
addq $0x1, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x341a
movl $0x15, %edi
leaq 0xdc54(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x14f9c(%rip) # imm = 0xFFFFFFFF
jmp 0x344e
cmpl $0x0, -0x8(%rbp)
je 0x3422
jmp 0x3422
movb -0x1(%rbp), %cl
movq 0x151a4(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x15196(%rip)     # 0x185d0
movb %cl, (%rax)
movq 0x15185(%rip), %rax     # 0x185c8
addq $0x1, %rax
movq %rax, 0x1517a(%rip)     # 0x185c8
jmp 0x3450
movl 0x14f4a(%rip), %eax     # 0x183a0
addl $0x1, %eax
movl %eax, 0x14f41(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, 0x14e9c(%rip)     # 0x183b4
jle 0x3594
movq 0x150a7(%rip), %rax     # 0x185c8
movslq -0x8(%rbp), %rcx
addq %rcx, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x354d
movl $0x15, %edi
leaq 0xdb21(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x14e69(%rip) # imm = 0xFFFFFFFF
jmp 0x3592
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x3580
movb -0x1(%rbp), %cl
movq 0x15062(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x15054(%rip)     # 0x185d0
movb %cl, (%rax)
jmp 0x3556
movslq -0x8(%rbp), %rax
addq 0x1503d(%rip), %rax     # 0x185c8
movq %rax, 0x15036(%rip)     # 0x185c8
jmp 0x3594
movl -0x8(%rbp), %eax
addl 0x14e03(%rip), %eax     # 0x183a0
movl %eax, 0x14dfd(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, 0x14dee(%rip)     # 0x183b4
jle 0x3654
movq 0x14ff5(%rip), %rax     # 0x185c8
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x35ff
movl $0x15, %edi
leaq 0xda6f(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x14db7(%rip) # imm = 0xFFFFFFFF
jmp 0x3652
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0x3640
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq 0x14fa2(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14f94(%rip)     # 0x185d0
movb %cl, (%rax)
jmp 0x3608
movslq -0xc(%rbp), %rax
addq 0x14f7d(%rip), %rax     # 0x185c8
movq %rax, 0x14f76(%rip)     # 0x185c8
jmp 0x3654
movl -0xc(%rbp), %eax
addl 0x14d43(%rip), %eax     # 0x183a0
movl %eax, 0x14d3d(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
cmpl $0x0, 0x14d2e(%rip)     # 0x183b4
jle 0x3712
movq 0x14f35(%rip), %rax     # 0x185c8
addq $0x2, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x36bc
movl $0x15, %edi
leaq 0xd9b2(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x14cfa(%rip) # imm = 0xFFFFFFFF
jmp 0x3710
movswl -0x2(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq 0x14f02(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14ef4(%rip)     # 0x185d0
movb %cl, (%rax)
movswl -0x2(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq 0x14ee2(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14ed4(%rip)     # 0x185d0
movb %cl, (%rax)
movq 0x14ec3(%rip), %rax     # 0x185c8
addq $0x2, %rax
movq %rax, 0x14eb8(%rip)     # 0x185c8
jmp 0x3712
movl 0x14c88(%rip), %eax     # 0x183a0
addl $0x2, %eax
movl %eax, 0x14c7f(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
cmpl $0x0, 0x14c6e(%rip)     # 0x183b4
jle 0x37d2
movq 0x14e75(%rip), %rax     # 0x185c8
addq $0x2, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x377c
movl $0x15, %edi
leaq 0xd8f2(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x14c3a(%rip) # imm = 0xFFFFFFFF
jmp 0x37d0
movswl -0x2(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq 0x14e44(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14e36(%rip)     # 0x185d0
movb %cl, (%rax)
movswl -0x2(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq 0x14e22(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14e14(%rip)     # 0x185d0
movb %cl, (%rax)
movq 0x14e03(%rip), %rax     # 0x185c8
addq $0x2, %rax
movq %rax, 0x14df8(%rip)     # 0x185c8
jmp 0x37d2
movl 0x14bc8(%rip), %eax     # 0x183a0
addl $0x2, %eax
movl %eax, 0x14bbf(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x14bb2(%rip)     # 0x183b4
jle 0x38cd
movq 0x14db9(%rip), %rax     # 0x185c8
addq $0x4, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x383b
movl $0x15, %edi
leaq 0xd836(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x14b7e(%rip) # imm = 0xFFFFFFFF
jmp 0x38cb
movl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq 0x14d84(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14d76(%rip)     # 0x185d0
movb %cl, (%rax)
movl -0x4(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq 0x14d65(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14d57(%rip)     # 0x185d0
movb %cl, (%rax)
movl -0x4(%rbp), %eax
sarl $0x10, %eax
movb %al, %cl
movq 0x14d46(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14d38(%rip)     # 0x185d0
movb %cl, (%rax)
movl -0x4(%rbp), %eax
sarl $0x18, %eax
movb %al, %cl
movq 0x14d27(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14d19(%rip)     # 0x185d0
movb %cl, (%rax)
movq 0x14d08(%rip), %rax     # 0x185c8
addq $0x4, %rax
movq %rax, 0x14cfd(%rip)     # 0x185c8
jmp 0x38cd
movl 0x14acd(%rip), %eax     # 0x183a0
addl $0x4, %eax
movl %eax, 0x14ac4(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x149b1(%rip)     # 0x183b4
jle 0x3b5a
movq 0x14bb8(%rip), %rax     # 0x185c8
addq $0x4, %rax
cmpq $0x200000, %rax         # imm = 0x200000
jle 0x3a3c
movl $0x15, %edi
leaq 0xd635(%rip), %rsi      # 0x1105d
callq 0xd130
movl $0xffffffff, 0x1497d(%rip) # imm = 0xFFFFFFFF
jmp 0x3b58
movq -0x8(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq 0x14b81(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14b73(%rip)     # 0x185d0
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
movb %al, %cl
movq 0x14b60(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14b52(%rip)     # 0x185d0
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x10, %rax
movb %al, %cl
movq 0x14b3f(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14b31(%rip)     # 0x185d0
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x18, %rax
movb %al, %cl
movq 0x14b1e(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14b10(%rip)     # 0x185d0
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x20, %rax
movb %al, %cl
movq 0x14afd(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14aef(%rip)     # 0x185d0
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x28, %rax
movb %al, %cl
movq 0x14adc(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14ace(%rip)     # 0x185d0
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x30, %rax
movb %al, %cl
movq 0x14abb(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14aad(%rip)     # 0x185d0
movb %cl, (%rax)
movq -0x8(%rbp), %rax
sarq $0x38, %rax
movb %al, %cl
movq 0x14a9a(%rip), %rax     # 0x185d0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x14a8c(%rip)     # 0x185d0
movb %cl, (%rax)
movq 0x14a7b(%rip), %rax     # 0x185c8
addq $0x8, %rax
movq %rax, 0x14a70(%rip)     # 0x185c8
jmp 0x3b5a
movl 0x14840(%rip), %eax     # 0x183a0
addl $0x4, %eax
movl %eax, 0x14837(%rip)     # 0x183a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3cf0
movq -0x28(%rbp), %rdi
leaq 0xc3e8(%rip), %rsi      # 0x10148
callq 0x3180
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x3d82
movq -0x28(%rbp), %rsi
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x3dcd
cmpq $0x0, -0x18(%rbp)
je 0x3d98
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3160
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x3080
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rdi
callq 0x3090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/lyxass.c
// Function: writeFile
int writeFile(char *fn,char *src,long len)
{
  FILE *f;

  if ( (f=fopen(fn,"wb+")) != NULL ){
    fwrite(src,len,1,f);
    fclose(f);
    return TRUE;
  } else {
    return FALSE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc34c(%rip), %rsi      # 0x1014b
callq 0x3180
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3e36
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x1, %edx
callq 0x31c0
movq -0x28(%rbp), %rdi
callq 0x3090
movl $0x1, -0x4(%rbp)
jmp 0x3e3d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x221c1(%rip), %rax     # 0x26d90
cmpq $0x0, (%rax)
je 0x4d1b
leaq 0x221b0(%rip), %rax     # 0x26d90
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4d19
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x4(%rax), %eax
andl $0x6, %eax
cmpl $0x2, %eax
jne 0x4d0c
cmpl $0x0, -0x14(%rbp)
je 0x4c39
movl $0x1d, %edi
leaq 0xc4ff(%rip), %rsi      # 0x1112c
callq 0xd130
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
addq $0x38, %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
addl $0x1, %edx
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
leaq 0x13b72(%rip), %rcx     # 0x187d0
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rax, %rcx
addq $0x4, %rcx
leaq 0xc3eb(%rip), %rdi      # 0x1105e
movb $0x0, %al
callq 0x30b0
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4ca3
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4cc0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x220c5(%rip), %rcx     # 0x26d90
cmpq (%rcx), %rax
jne 0x4ce1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x220b2(%rip), %rax     # 0x26d90
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x220ac(%rip), %rcx     # 0x26d98
cmpq (%rcx), %rax
jne 0x4d03
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x22098(%rip), %rax     # 0x26d98
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3040
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4bee
jmp 0x4d1b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa000
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x5008
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5066
cmpl $0x0, 0x135f5(%rip)     # 0x18604
je 0x501a
movl $0x0, -0x4(%rbp)
jmp 0x5066
movq -0x10(%rbp), %rdi
callq 0xb9d0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x5033
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5066
movq -0x10(%rbp), %rdi
callq 0xcd90
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jne 0x5060
cmpl $0x0, -0x14(%rbp)
je 0x5060
movl $0x12, %edi
leaq 0xc007(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0x5066
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x1312d(%rip), %rax     # 0x185f8
cmpq $0x0, 0x198(%rax)
je 0x551a
leaq 0x1311c(%rip), %rax     # 0x185f8
movq 0x198(%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x13107(%rip), %rcx     # 0x185f8
movq %rdx, 0x198(%rcx)
movsbl (%rax), %eax
movl %eax, 0x1b8ff(%rip)     # 0x20e00
leaq 0x130f0(%rip), %rax     # 0x185f8
movq 0x198(%rax), %rax
movsbl (%rax), %eax
movl %eax, 0x1b8ec(%rip)     # 0x20e04
jmp 0x552e
movl $0xffffffff, 0x1b8dc(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x1b8d6(%rip) # imm = 0xFFFFFFFF
movl 0x1b8cc(%rip), %eax     # 0x20e00
movl %eax, -0x4(%rbp)
incl %eax
subl $0x2, %eax
jb 0x5568
jmp 0x5540
movl -0x4(%rbp), %eax
subl $0x9, %eax
je 0x5592
jmp 0x554a
movl -0x4(%rbp), %eax
subl $0xa, %eax
je 0x5586
jmp 0x5554
movl -0x4(%rbp), %eax
subl $0xd, %eax
je 0x5592
jmp 0x555e
movl -0x4(%rbp), %eax
subl $0x20, %eax
je 0x5592
jmp 0x559e
movl $0xffffffff, 0x1b88e(%rip) # imm = 0xFFFFFFFF
leaq 0x1307f(%rip), %rax     # 0x185f8
movq $0x0, 0x198(%rax)
jmp 0x55a0
movl $0xfffffffe, 0x1b870(%rip) # imm = 0xFFFFFFFE
jmp 0x55a0
movl $0x20, 0x1b864(%rip)    # 0x20e00
jmp 0x55a0
jmp 0x55a0
xorl %eax, %eax
cmpl $-0x1, 0x1b857(%rip)    # 0x20e00
movb %al, -0x5(%rbp)
je 0x55bb
cmpl $-0x2, 0x1b84b(%rip)    # 0x20e00
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x13016(%rip), %rax     # 0x185f8
movl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1c79e(%rip), %rax     # 0x21d90
imulq $0x500, %rcx, %rcx      # imm = 0x500
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5638
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x560b
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/parser.c
// Function: GetAtom
int GetAtom(void)
{
  last_atom = atom;
  atom = *srcLinePtr++;
  next_atom = *srcLinePtr;

  if ( !atom ) srcLinePtr--;

  return atom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x1b536(%rip), %eax     # 0x20f20
movl %eax, 0x1b534(%rip)     # 0x20f24
movq 0x1b519(%rip), %rax     # 0x20f10
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1b50b(%rip)     # 0x20f10
movsbl (%rax), %eax
movl %eax, 0x1b512(%rip)     # 0x20f20
movq 0x1b4fb(%rip), %rax     # 0x20f10
movsbl (%rax), %eax
movl %eax, 0x1b50a(%rip)     # 0x20f28
cmpl $0x0, 0x1b4fb(%rip)     # 0x20f20
jne 0x5a39
movq 0x1b4e2(%rip), %rax     # 0x20f10
addq $-0x1, %rax
movq %rax, 0x1b4d7(%rip)     # 0x20f10
movl 0x1b4e1(%rip), %eax     # 0x20f20
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/parser.c
// Function: TestAtom
int TestAtom(int x)
{
  KillSpace();
  if ( atom == (x) ){
    GetAtom();
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x5ad0
movl 0x1b47a(%rip), %eax     # 0x20f20
cmpl -0x8(%rbp), %eax
jne 0x5ab9
callq 0x59e0
movl $0x1, -0x4(%rbp)
jmp 0x5ac0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x5ad0
movl 0x1b417(%rip), %eax     # 0x20f20
cmpl -0x8(%rbp), %eax
je 0x5b19
movl 0x1b40c(%rip), %eax     # 0x20f20
cmpl -0xc(%rbp), %eax
jne 0x5b27
callq 0x59e0
movl $0x1, -0x4(%rbp)
jmp 0x5b2e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x1b3c5(%rip)     # 0x20f20
movb %al, -0x12(%rbp)
je 0x5b72
movl 0x1b3ba(%rip), %eax     # 0x20f20
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x5b7b
jmp 0x5b9b
movl 0x1b39f(%rip), %eax     # 0x20f20
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
callq 0x59e0
jmp 0x5b52
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movsbl -0x11(%rbp), %edi
callq 0x5a90
cmpl $0x0, %eax
je 0x5bb9
movl $0x1, -0x4(%rbp)
jmp 0x5bc0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)