в чем проблема не получается скомпилировать код на си и асемблере: #include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define error(...) (fprintf(stderr, __VA_ARGS__))
#define array_length(x) (sizeof(x) / sizeof(x[0]))

#ifndef QUICKSORT_H
#define QUICKSORT_H

extern void quick_sort(int arr[], int low, int high, int *moved_numbers);

#endif

int validate_arguments(int argc, char *argv[], int *the_lowest_number, int *the_greatest_number) {
	if (argc == 1) {
		return -1;
	}
	if (argc > 3) {
		return -2;
	}

	int count_of_arguments_to = 0;
	int count_of_arguments_from = 0;

	for (int i = 1; i < argc; ++i) {
		if (strncmp(argv[i], "--to=", 5) == 0) {
			count_of_arguments_to++;
			char *number_str = argv[i] + 5;
			char *endptr;
			long parsed_number = strtol(number_str, &endptr, 10);

			if (number_str == endptr || *endptr != '\0'){
				return -5;
			}
			*the_greatest_number = (int)parsed_number;
		}
		if (strncmp(argv[i], "--from=", 7) == 0) {
			count_of_arguments_from++;
			char *number_str = argv[i] + 7;
			char *endptr;
			long parsed_number = strtol(number_str, &endptr, 10);
			
			if (number_str == endptr || *endptr != '\0'){
				return -5;
			}
			*the_lowest_number = (int)parsed_number;
		}
	}

	if (count_of_arguments_to > 1 || count_of_arguments_from > 1) {
		return -3;
	}
	if (count_of_arguments_to == 0 && count_of_arguments_from == 0) {
		return -4;
	}
	return 0;
}

int* creating_of_array(int the_lowest_number, int the_greatest_number){
	int oversaturated_not_sortable_array[100];
	int count_of_entered_numbers = 0;
	int count_of_added_numbers = 0;
	int current_input_number;

	printf("Enter numbers separated by spaces (or \\n to complete):\n");
	//тут надо  приколов 
	while(count_of_entered_numbers < 100){
		if (! scanf("%d", &current_input_number)){
			break;
		}
		if (current_input_number <= the_lowest_number){
			printf("%d ", current_input_number);
		}
		else if (current_input_number >= the_greatest_number){
			error("%d ", current_input_number);
		}
		else{
		oversaturated_not_sortable_array[count_of_added_numbers] = current_input_number;
		count_of_added_numbers++;
		}
		count_of_entered_numbers++;
	}

	int* complete_sortable_array = (int*)malloc(count_of_added_numbers * sizeof(int));
	if (complete_sortable_array == NULL){
		error("Memory allocation error");
		exit(1);
	}
	for (int j = 0; j < count_of_added_numbers; ++j){
		complete_sortable_array[j] = oversaturated_not_sortable_array[j];

	}
	return complete_sortable_array;
}

int main(int argc, char *argv[]) {
	int the_lowest_number = 0;
	int the_greatest_number = 0;

	int validation_result = validate_arguments(argc, argv, &the_lowest_number, &the_greatest_number);

	if (validation_result != 0){
		return validation_result;
	}
	int* complete_sortable_array = creating_of_array(the_lowest_number, the_greatest_number);
	int lenth_of_comlete_sortable_array = array_length(complete_sortable_array);
		printf(" MASSIVE: ");
	for(int i = 0; i < lenth_of_comlete_sortable_array; ++i){
		printf("%d\n", complete_sortable_array[i]);
	}

	int moved_numbers = 0;
	
	quick_sort(complete_sortable_array, 0, lenth_of_comlete_sortable_array, &moved_numbers);

	for(int i = 0; i < lenth_of_comlete_sortable_array; ++i){
		printf("%d\n", complete_sortable_array[i]);
	}
}

и вот код на асемблере :
.section .text
.global swap
.type swap, @function
swap:
    movq    (%rdi), %rax
    movq    (%rsi), %rdx
    movq    %rdx, (%rdi)
    movq    %rax, (%rsi)
    ret

.section .text
.global partition
.type partition, @function
partition:
    movq    8(%rdi), %rcx
    movq    16(%rdi), %rdi
    subq    $1, %rcx
    movq    (%rdi), %rax
    movq    %rcx, %rsi

.loop:
    addq    $1, %rsi
    movq    (%rsi), %rdx
    cmpq    %rax, %rdx
    jg      .skip_swap
    movq    %rdx, %rbx
    movq    (%rdi), %rdx
    movq    %rbx, (%rdi)
    movq    %rdx, (%rsi)
.skip_swap:
    cmpq    %rdi, %rsi
    jl      .loop
    addq    $1, %rcx
    movq    %rcx, %rdi
    movq    (%rdi), %rax
    movq    (%rdi,%rcx,4), %rbx
    movq    %rax, (%rdi,%rcx,4)
    movq    %rbx, (%rdi)
    ret

.section .text
.global quick_sort
.type quick_sort, @function
quick_sort:
    movq    8(%rdi), %rdx
    movq    16(%rdi), %rcx
    cmpq    %rdx, %rcx
    jge     .end
    pushq   %rdi
    pushq   %rsi
    pushq   %rdx
    pushq   %rcx
    call    partition
    addq    $32, %rsp
    popq    %rcx
    popq    %rdx
    popq    %rsi
    popq    %rdi
    movq    %rdx, %rax
    subq    $1, %rax
    pushq   %rdi
    pushq   %rax
    call    quick_sort
    addq    $16, %rsp
    popq    %rax
    addq    $2, %rax
    pushq   %rax
    pushq   %rcx
    call    quick_sort
    addq    $16, %rsp
    popq    %rcx
    popq    %rdi
.end:
    ret