Вывести координаты вершин выпуклой оболочки, отсортированные в порядке возрастания по их абсциссам

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define size 100
 
int location(int x1, int y1, int x2, int y2, int x3, int y3)
{
    if ((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1) > 0)
        return 1; //тчк нах-ся выше
    if ((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1) < 0)
        return -1;//тчк нах-ся ниже
}
int distance(int x, int y, int A, int B, int C)
{
    return (abs(A * x + B * y + C) / sqrt(pow(A, 2) + pow(B, 2)));
}
void sort(int* VERT_x, int* VERT_y, int* vert_c)
{
    int i = 0, j = 0, temp = 0;
        for (int i = 0; i < *vert_c - 1; ++i)
        {
            for (j = *vert_c - 1; j > i; --j) 
            {
                if (VERT_x[j] > VERT_x[j + 1])
                {
                    temp = VERT_x[j];
                    VERT_x[j] = VERT_x[j + 1];
                    VERT_x[j + 1] = temp;
                }
                else
                    if (VERT_x[j] == VERT_x[j + 1])
                    {
                        if (VERT_y[j] < VERT_y[j + 1])
                        {
                            temp = VERT_x[j];
                            VERT_x[j] = VERT_x[j + 1];
                            VERT_x[j + 1] = temp;
                        }
                    }
            }
        }
}
 
int vertex(int upper_points_c, int* UPPER_points_x, int* UPPER_points_y, int x1, int y1, int x2, int y2, int* VERT_x, int* VERT_y, int* vert_c)
{
    if (upper_points_c == 0)
        return 0;
    else
    {
        int max_d = 0, max_d_x = 0, max_d_y = 0, i = 0;
        int new_upper_points_c1 = 0, new_upper_points_c2 = 0;
        int new_upper_X1[size] = { 0 };
        int new_upper_Y1[size] = { 0 };
        int new_upper_X2[size] = { 0 };
        int new_upper_Y2[size] = { 0 };
        int A = y1 - y2, B = x2 - x1, C = x1 * y2 - x2 * y1;//находим коэф-ты
        for (i = 0; i < upper_points_c; ++i)
        {
            if (distance(UPPER_points_x[i], UPPER_points_y[i], A, B, C) > max_d) //находим самую дальнюю точку
            {
                max_d = distance(UPPER_points_x[i], UPPER_points_y[i], A, B, C);
                max_d_x = UPPER_points_x[i];
                max_d_y = UPPER_points_y[i];
            }
        }
        for (i = 0; i < upper_points_c; ++i)
        {
            if (location(x1, y1, max_d_x, max_d_y, UPPER_points_x[i], UPPER_points_y[i]) == 1)//?????
            {
                new_upper_X1[new_upper_points_c1] = UPPER_points_x[i]; //если тчк выше прямой, то добавляем ее коорд-ты в массивы
                new_upper_Y1[new_upper_points_c1] = UPPER_points_y[i];
                ++new_upper_points_c1;
            }
            if (location(max_d_x, max_d_y, x2, y2, UPPER_points_x[i], UPPER_points_y[i]) == 1)//?????
            {
                new_upper_X2[new_upper_points_c2] = UPPER_points_x[i]; //если тчк выше прямой, то добавляем ее коорд-ты в массивы
                new_upper_Y2[new_upper_points_c2] = UPPER_points_y[i];
                ++new_upper_points_c2;
            }
        }
        if (new_upper_points_c1 != 0)//если есть вышележащие точки
        {
            vertex(new_upper_points_c1, new_upper_X1, new_upper_Y1, x1, y1, max_d_x, max_d_y, VERT_x, VERT_y, vert_c);
        }
        else
        {
            VERT_x[*vert_c] = max_d_x;
            VERT_y[*vert_c] = max_d_y;
            ++* vert_c;
        }
        if (new_upper_points_c2 != 0)//  --||--
        {
            vertex(new_upper_points_c2, new_upper_X2, new_upper_Y2, x2, y2, max_d_x, max_d_y, VERT_x, VERT_y, vert_c);
        }
        else
        {
            if (VERT_x[*vert_c - 1] != max_d_x && VERT_y[*vert_c - 1] != max_d_y)
            {
                VERT_x[*vert_c] = max_d_x;
                VERT_y[*vert_c] = max_d_y;
                ++* vert_c;
            }
        }
        return 1;
    }
}
 
int main()
{
    FILE* fr;
    int i = 0, points_c = 0, upper_points_c = 0, vert_c = 0;
    int UPPER_points_x[size] = { 0 };
    int UPPER_points_y[size] = { 0 };
    int LOWER_points_x[size] = { 0 };
    int LOWER_points_y[size] = { 0 };
    int lower_points_c = 0;
    int VERT_x[size] = { 0 };
    int VERT_y[size] = { 0 };
    char str[size] = { 0 };
    char temp_str[size] = { 0 };
    int X[size] = { 0 };
    int Y[size] = { 0 };
    fr = fopen("input.txt", "r");
    fgets(temp_str, size, fr);
    while (!feof(fr))//ввод данных
    {
        fgets(str, size, fr);
        sscanf(temp_str, "%d %d", &X[points_c], &Y[points_c]);
        ++points_c;
        if (strcmp(str, temp_str) != 0)
            strcpy(temp_str, str);
    }
    --points_c;
    int min_x = X[0], max_x = X[0], min_y=Y[0], max_y=Y[0]; 
    for (i = 0; i < points_c; ++i) //поиск стартовых точек
    {
        if (X[i] > max_x)
        {
            max_x = X[i];
            max_y = Y[i];
        }
        if (X[i] < min_x)
        {
            min_x = X[i];
            min_y = Y[i];
        }
    }
    VERT_x[vert_c] = min_x, VERT_y[vert_c] = min_y;
    ++vert_c;
    for (i = 0; i < points_c; ++i)
    {
        if (location(min_x, min_y, max_x, max_y, X[i], Y[i]) == 1)
        {
            UPPER_points_x[upper_points_c] = X[i];
            UPPER_points_y[upper_points_c] = Y[i];
            ++upper_points_c;
        }
        if (location(min_x, min_y, max_x, max_y, X[i], Y[i]) == -1)
        {
            LOWER_points_x[lower_points_c] = X[i];
            LOWER_points_y[lower_points_c] = Y[i];
            ++lower_points_c;
        }
    }
    vertex(upper_points_c, UPPER_points_x, UPPER_points_y, min_x, min_y, max_x, max_y, VERT_x, VERT_y, &vert_c);
    vertex(lower_points_c, LOWER_points_x, LOWER_points_y, min_x, min_y, max_x, max_y, VERT_x, VERT_y, &vert_c);
    VERT_x[vert_c] = max_x, VERT_y[vert_c] = max_y;
    sort(VERT_x, VERT_y, &vert_c+1);
    printf("Convex Hull is:\n");
    for (i = 0; i <= vert_c; ++i)
        printf("%d %d\n", VERT_x[i], VERT_y[i]);
    fclose(fr);
    return 0;
}

int location(int x1, int y1, int x2, int y2, int x3, int y3){
    int result = (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1);
    if (rezult > 0) return 1; //тчк нах-ся выше
    if (rezult < 0) return -1;//тчк нах-ся ниже
    return 0; // result = 0
}