---

Задание 1
#include <stdio.h>
#include <stdlib.h>

int input_array(int *array, int n);
void sort_array(int *array, int n);
void output_array(int *array, int n);

int main(void) {
    int n;
    int *array = NULL;

    if (scanf("%d", &n) != 1 || n <= 0) {
        printf("n/a");
    } else {
        array = malloc(n * sizeof(int));
        if (array == NULL || input_array(array, n) == 0) {
            printf("n/a");
        } else {
            sort_array(array, n);
            output_array(array, n);
        }
    }

    free(array);
    return 0;
}

int input_array(int *array, int n) {
    int result = 1;

    for (int i = 0; i < n; i++) {
        if (scanf("%d", &array[i]) != 1) {
            result = 0;
        }
    }

    return result;
}

void sort_array(int *array, int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

void output_array(int *array, int n) {
    for (int i = 0; i < n; i++) {
        if (i > 0) {
            printf(" ");
        }
        printf("%d", array[i]);
    }
}
Зажние 2
#include <stdio.h>
#include <stdlib.h>

int input_array(int *array, int n);
void sort_array(int *array, int n);
void output_array(int *array, int n);

int main(void) {
    int n;
    int *array = NULL;

    if (scanf("%d", &n) != 1 || n <= 0) {
        printf("n/a");
    } else {
        array = malloc(n * sizeof(int));
        if (array == NULL || input_array(array, n) == 0) {
            printf("n/a");
        } else {
            sort_array(array, n);
            output_array(array, n);
        }
    }

    free(array);
    return 0;
}

int input_array(int *array, int n) {
    int result = 1;

    for (int i = 0; i < n; i++) {
        if (scanf("%d", &array[i]) != 1) {
            result = 0;
        }
    }

    return result;
}

void sort_array(int *array, int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

void output_array(int *array, int n) {
    for (int i = 0; i < n; i++) {
        if (i > 0) {
            printf(" ");
        }
        printf("%d", array[i]);
    }
}
Задние 3
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

int input_size(int *n, int *m);
int input_matrix(int **matrix, int n, int m);
void output_matrix(int **matrix, int n, int m);
int allocate_matrix(int ***matrix, int **data, int method, int n, int m);
void free_matrix(int **matrix, int *data, int method, int n);

int main(void) {
    int method;
    int n;
    int m;
    int **matrix = NULL;
    int *data = NULL;
    int static_data[MAX_SIZE][MAX_SIZE];
    int *static_rows[MAX_SIZE];
    int error = 0;

    if (scanf("%d", &method) != 1 || method < 1 || method > 4 || input_size(&n, &m) == 0) {
        error = 1;
    } else if (method == 1) {
        if (n > MAX_SIZE || m > MAX_SIZE) {
            error = 1;
        } else {
            for (int i = 0; i < n; i++) {
                static_rows[i] = static_data[i];
            }
            matrix = static_rows;
        }
    } else if (allocate_matrix(&matrix, &data, method, n, m) == 0) {
        error = 1;
    }

    if (error == 0 && input_matrix(matrix, n, m) == 0) {
        error = 1;
    }

    if (error == 1) {
        printf("n/a");
    } else {
        output_matrix(matrix, n, m);
    }

    if (method >= 2 && method <= 4) {
        free_matrix(matrix, data, method, n);
    }

    return 0;
}

int input_size(int *n, int *m) {
    int result = 1;

    if (scanf("%d %d", n, m) != 2 || *n <= 0 || *m <= 0) {
        result = 0;
    }

    return result;
}

int input_matrix(int **matrix, int n, int m) {
    int result = 1;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (scanf("%d", &matrix[i][j]) != 1) {
                result = 0;
            }
        }
    }

    return result;
}

void output_matrix(int **matrix, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (j > 0) {
                printf(" ");
            }
            printf("%d", matrix[i][j]);
        }
        if (i < n - 1) {
            printf("\n");
        }
    }
}

int allocate_matrix(int ***matrix, int **data, int method, int n, int m) {
    int result = 1;

    if (method == 2) {
        *matrix = malloc(n * sizeof(int *));
        *data = malloc(n * m * sizeof(int));
        if (*matrix == NULL || *data == NULL) {
            result = 0;
        } else {
            for (int i = 0; i < n; i++) {
                (*matrix)[i] = *data + i * m;
            }
        }
    } else if (method == 3) {
        *matrix = malloc(n * sizeof(int *));
        if (*matrix == NULL) {
            result = 0;
        } else {
            for (int i = 0; i < n; i++) {
                (*matrix)[i] = malloc(m * sizeof(int));
                if ((*matrix)[i] == NULL) {
                    result = 0;
                }
            }
        }
    } else if (method == 4) {
        *matrix = malloc(n * sizeof(int *) + n * m * sizeof(int));
        if (*matrix == NULL) {
            result = 0;
        } else {
            *data = (int *)(*matrix + n);
            for (int i = 0; i < n; i++) {
                (*matrix)[i] = *data + i * m;
            }
        }
    }

    if (result == 0) {
        free_matrix(*matrix, *data, method, n);
        *matrix = NULL;
        *data = NULL;
    }

    return result;
}

void free_matrix(int **matrix, int *data, int method, int n) {
    if (method == 2) {
        free(data);
        free(matrix);
    } else if (method == 3) {
        if (matrix != NULL) {
            for (int i = 0; i < n; i++) {
                free(matrix[i]);
            }
            free(matrix);
        }
    } else if (method == 4) {
        free(matrix);
    }
}
Задание 4
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

int input_size(int *n, int *m);
int input_matrix(int **matrix, int n, int m);
void output_matrix(int **matrix, int n, int m);
void output_array(int *array, int n);
int allocate_matrix(int ***matrix, int **data, int method, int n, int m);
void free_matrix(int **matrix, int *data, int method, int n);
void find_row_max(int **matrix, int n, int m, int *row_max);
void find_column_min(int **matrix, int n, int m, int *column_min);

int main(void) {
    int method;
    int n;
    int m;
    int **matrix = NULL;
    int *data = NULL;
    int *row_max = NULL;
    int *column_min = NULL;
    int static_data[MAX_SIZE][MAX_SIZE];
    int *static_rows[MAX_SIZE];
    int error = 0;

    if (scanf("%d", &method) != 1 || method < 1 || method > 4 || input_size(&n, &m) == 0) {
        error = 1;
    } else if (method == 1) {
        if (n > MAX_SIZE || m > MAX_SIZE) {
            error = 1;
        } else {
            for (int i = 0; i < n; i++) {
                static_rows[i] = static_data[i];
            }
            matrix = static_rows;
        }
    } else if (allocate_matrix(&matrix, &data, method, n, m) == 0) {
        error = 1;
    }

    if (error == 0) {
        row_max = malloc(n * sizeof(int));
        column_min = malloc(m * sizeof(int));
        if (row_max == NULL || column_min == NULL || input_matrix(matrix, n, m) == 0) {
            error = 1;
        }
    }

    if (error == 1) {
        printf("n/a");
    } else {
        find_row_max(matrix, n, m, row_max);
        find_column_min(matrix, n, m, column_min);
        output_matrix(matrix, n, m);
        printf("\n");
        output_array(row_max, n);
        printf("\n");
        output_array(column_min, m);
    }

    free(row_max);
    free(column_min);
    if (method >= 2 && method <= 4) {
        free_matrix(matrix, data, method, n);
    }

    return 0;
}

int input_size(int *n, int *m) {
    int result = 1;

    if (scanf("%d %d", n, m) != 2 || *n <= 0 || *m <= 0) {
        result = 0;
    }

    return result;
}

int input_matrix(int **matrix, int n, int m) {
    int result = 1;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (scanf("%d", &matrix[i][j]) != 1) {
                result = 0;
            }
        }
    }

    return result;
}

void output_matrix(int **matrix, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (j > 0) {
                printf(" ");
            }
            printf("%d", matrix[i][j]);
        }
        if (i < n - 1) {
            printf("\n");
        }
    }
}

void output_array(int *array, int n) {
    for (int i = 0; i < n; i++) {
        if (i > 0) {
            printf(" ");
        }
        printf("%d", array[i]);
    }
}

int allocate_matrix(int ***matrix, int **data, int method, int n, int m) {
    int result = 1;

    if (method == 2) {
        *matrix = malloc(n * sizeof(int *));
        *data = malloc(n * m * sizeof(int));
        if (*matrix == NULL || *data == NULL) {
            result = 0;
        } else {
            for (int i = 0; i < n; i++) {
                (*matrix)[i] = *data + i * m;
            }
        }
    } else if (method == 3) {
        *matrix = malloc(n * sizeof(int *));
        if (*matrix == NULL) {
            result = 0;
        } else {
            for (int i = 0; i < n; i++) {
                (*matrix)[i] = malloc(m * sizeof(int));
                if ((*matrix)[i] == NULL) {
                    result = 0;
                }
            }
        }
    } else if (method == 4) {
        *matrix = malloc(n * sizeof(int *) + n * m * sizeof(int));
        if (*matrix == NULL) {
            result = 0;
        } else {
            *data = (int *)(*matrix + n);
            for (int i = 0; i < n; i++) {
                (*matrix)[i] = *data + i * m;
            }
        }
    }

    if (result == 0) {
        free_matrix(*matrix, *data, method, n);
        *matrix = NULL;
        *data = NULL;
    }

    return result;
}

void free_matrix(int **matrix, int *data, int method, int n) {
    if (method == 2) {
        free(data);
        free(matrix);
    } else if (method == 3) {
        if (matrix != NULL) {
            for (int i = 0; i < n; i++) {
                free(matrix[i]);
            }
            free(matrix);
        }
    } else if (method == 4) {
        free(matrix);
    }
}

void find_row_max(int **matrix, int n, int m, int *row_max) {
    for (int i = 0; i < n; i++) {
        row_max[i] = matrix[i][0];
        for (int j = 1; j < m; j++) {
            if (matrix[i][j] > row_max[i]) {
                row_max[i] = matrix[i][j];
            }
        }
    }
}

void find_column_min(int **matrix, int n, int m, int *column_min) {
    for (int j = 0; j < m; j++) {
        column_min[j] = matrix[0][j];
        for (int i = 1; i < n; i++) {
            if (matrix[i][j] < column_min[j]) {
                column_min[j] = matrix[i][j];
            }
        }
    }
}
Задние 5
#include <stdio.h>

#define N 15
#define M 13

void transform(int *buf, int **matr, int n, int m);
void make_picture(int **picture, int n, int m);
void reset_picture(int **picture, int n, int m);
void output_picture(int **picture, int n, int m);

int main(void) {
    int picture_data[N][M];
    int *picture[N];

    transform((int *)picture_data, picture, N, M);
    make_picture(picture, N, M);
    output_picture(picture, N, M);

    return 0;
}

void make_picture(int **picture, int n, int m) {
    int frame_w[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
    int frame_h[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
    int tree_trunk[] = {7, 7, 7, 7};
    int tree_foliage[] = {3, 3, 3, 3};
    int sun_data[6][5] = {{0, 6, 6, 6, 6},
                          {0, 0, 6, 6, 6},
                          {0, 0, 6, 6, 6},
                          {0, 6, 0, 0, 6},
                          {0, 0, 0, 0, 0},
                          {0, 0, 0, 0, 0}};

    reset_picture(picture, n, m);

    for (int j = 0; j < m; j++) {
        picture[0][j] = frame_w[j];
        picture[7][j] = frame_w[j];
        picture[n - 1][j] = frame_w[j];
    }

    for (int i = 0; i < n; i++) {
        picture[i][0] = frame_h[i];
        picture[i][6] = frame_h[i];
        picture[i][m - 1] = frame_h[i];
    }

    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 5; j++) {
            picture[i + 1][j + 7] = sun_data[i][j];
        }
    }

    for (int j = 0; j < 2; j++) {
        picture[2][j + 3] = tree_foliage[j];
        picture[5][j + 3] = tree_foliage[j];
    }

    for (int j = 0; j < 4; j++) {
        picture[3][j + 2] = tree_foliage[j];
        picture[4][j + 2] = tree_foliage[j];
        picture[10][j + 2] = tree_trunk[j];
    }

    for (int j = 0; j < 2; j++) {
        picture[6][j + 3] = tree_trunk[j];
        picture[8][j + 3] = tree_trunk[j];
        picture[9][j + 3] = tree_trunk[j];
    }
}

void reset_picture(int **picture, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            picture[i][j] = 0;
        }
    }
}

void transform(int *buf, int **matr, int n, int m) {
    for (int i = 0; i < n; i++) {
        matr[i] = buf + i * m;
    }
}

void output_picture(int **picture, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (j > 0) {
                printf(" ");
            }
            printf("%d", picture[i][j]);
        }
        if (i < n - 1) {
            printf("\n");
        }
    }
}
Задание 6
#include <stdio.h>
#include <stdlib.h>

int input_matrix(int ***matrix, int *n, int *m);
void output_matrix(int **matrix, int n, int m);
int **allocate_matrix(int n, int m);
void free_matrix(int **matrix);
int sum(int **first, int n_first, int m_first, int **second, int n_second, int m_second,
        int ***result, int *n_result, int *m_result);
int mul(int **first, int n_first, int m_first, int **second, int n_second, int m_second,
        int ***result, int *n_result, int *m_result);
int transpose(int **matrix, int n, int m, int ***result, int *n_result, int *m_result);

int main(void) {
    int operation;
    int **first = NULL;
    int **second = NULL;
    int **result = NULL;
    int n_first;
    int m_first;
    int n_second;
    int m_second;
    int n_result;
    int m_result;
    int error = 0;

    if (scanf("%d", &operation) != 1 || operation < 1 || operation > 3) {
        error = 1;
    } else if (input_matrix(&first, &n_first, &m_first) == 0) {
        error = 1;
    } else if (operation == 1 || operation == 2) {
        if (input_matrix(&second, &n_second, &m_second) == 0) {
            error = 1;
        }
    }

    if (error == 0) {
        if (operation == 1) {
            error = !sum(first, n_first, m_first, second, n_second, m_second, &result, &n_result,
                         &m_result);
        } else if (operation == 2) {
            error = !mul(first, n_first, m_first, second, n_second, m_second, &result, &n_result,
                         &m_result);
        } else {
            error = !transpose(first, n_first, m_first, &result, &n_result, &m_result);
        }
    }

    if (error == 1) {
        printf("n/a");
    } else {
        output_matrix(result, n_result, m_result);
    }

    free_matrix(first);
    free_matrix(second);
    free_matrix(result);

    return 0;
}

int input_matrix(int ***matrix, int *n, int *m) {
    int result = 1;

    if (scanf("%d %d", n, m) != 2 || *n <= 0 || *m <= 0) {
        result = 0;
    } else {
        *matrix = allocate_matrix(*n, *m);
        if (*matrix == NULL) {
            result = 0;
        } else {
            for (int i = 0; i < *n; i++) {
                for (int j = 0; j < *m; j++) {
                    if (scanf("%d", &(*matrix)[i][j]) != 1) {
                        result = 0;
                    }
                }
            }
        }
    }

    return result;
}

void output_matrix(int **matrix, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (j > 0) {
                printf(" ");
            }
            printf("%d", matrix[i][j]);
        }
        if (i < n - 1) {
            printf("\n");
        }
    }
}

int **allocate_matrix(int n, int m) {
    int **matrix = malloc(n * sizeof(int *) + n * m * sizeof(int));

    if (matrix != NULL) {
        int *data = (int *)(matrix + n);
        for (int i = 0; i < n; i++) {
            matrix[i] = data + i * m;
        }
    }

    return matrix;
}

void free_matrix(int **matrix) {
    free(matrix);
}

int sum(int **first, int n_first, int m_first, int **second, int n_second, int m_second,
        int ***result, int *n_result, int *m_result) {
    int success = 1;

    if (n_first != n_second || m_first != m_second) {
        success = 0;
    } else {
        *n_result = n_first;
        *m_result = m_first;
        *result = allocate_matrix(*n_result, *m_result);
        if (*result == NULL) {
            success = 0;
        } else {
            for (int i = 0; i < *n_result; i++) {
                for (int j = 0; j < *m_result; j++) {
                    (*result)[i][j] = first[i][j] + second[i][j];
                }
            }
        }
    }

    return success;
}

int mul(int **first, int n_first, int m_first, int **second, int n_second, int m_second,
        int ***result, int *n_result, int *m_result) {
    int success = 1;

    if (m_first != n_second) {
        success = 0;
    } else {
        *n_result = n_first;
        *m_result = m_second;
        *result = allocate_matrix(*n_result, *m_result);
        if (*result == NULL) {
            success = 0;
        } else {
            for (int i = 0; i < *n_result; i++) {
                for (int j = 0; j < *m_result; j++) {
                    (*result)[i][j] = 0;
                    for (int k = 0; k < m_first; k++) {
                        (*result)[i][j] += first[i][k] * second[k][j];
                    }
                }
            }
        }
    }

    return success;
}

int transpose(int **matrix, int n, int m, int ***result, int *n_result, int *m_result) {
    int success = 1;

    *n_result = m;
    *m_result = n;
    *result = allocate_matrix(*n_result, *m_result);
    if (*result == NULL) {
        success = 0;
    } else {
        for (int i = 0; i < *n_result; i++) {
            for (int j = 0; j < *m_result; j++) {
                (*result)[i][j] = matrix[j][i];
            }
        }
    }

    return success;
}
Задние 7
#include <stdio.h>
#include <stdlib.h>

#define EPS 0.0000001

double det(double **matrix, int n);
int input(double ***matrix, int *n, int *m);
void output(double value);
double **allocate_matrix(int n, int m);
void free_matrix(double **matrix);
double abs_double(double value);
void swap_rows(double **matrix, int first, int second);

int main(void) {
    double **matrix = NULL;
    int n;
    int m;

    if (input(&matrix, &n, &m) == 0 || n != m) {
        printf("n/a");
    } else {
        output(det(matrix, n));
    }

    free_matrix(matrix);
    return 0;
}

double det(double **matrix, int n) {
    double result = 1.0;
    int sign = 1;

    for (int i = 0; i < n; i++) {
        int pivot = i;
        for (int j = i + 1; j < n; j++) {
            if (abs_double(matrix[j][i]) > abs_double(matrix[pivot][i])) {
                pivot = j;
            }
        }

        if (abs_double(matrix[pivot][i]) < EPS) {
            result = 0.0;
        } else {
            if (pivot != i) {
                swap_rows(matrix, pivot, i);
                sign *= -1;
            }

            for (int j = i + 1; j < n; j++) {
                double factor = matrix[j][i] / matrix[i][i];
                for (int k = i; k < n; k++) {
                    matrix[j][k] -= factor * matrix[i][k];
                }
            }
        }
    }

    if (abs_double(result) >= EPS) {
        for (int i = 0; i < n; i++) {
            result *= matrix[i][i];
        }
        result *= sign;
    }

    if (abs_double(result) < EPS) {
        result = 0.0;
    }

    return result;
}

int input(double ***matrix, int *n, int *m) {
    int success = 1;

    if (scanf("%d %d", n, m) != 2 || *n <= 0 || *m <= 0) {
        success = 0;
    } else {
        *matrix = allocate_matrix(*n, *m);
        if (*matrix == NULL) {
            success = 0;
        } else {
            for (int i = 0; i < *n; i++) {
                for (int j = 0; j < *m; j++) {
                    if (scanf("%lf", &(*matrix)[i][j]) != 1) {
                        success = 0;
                    }
                }
            }
        }
    }

    return success;
}

void output(double value) {
    printf("%.6lf", value);
}

double **allocate_matrix(int n, int m) {
    double **matrix = malloc(n * sizeof(double *) + n * m * sizeof(double));

    if (matrix != NULL) {
        double *data = (double *)(matrix + n);
        for (int i = 0; i < n; i++) {
            matrix[i] = data + i * m;
        }
    }

    return matrix;
}

void free_matrix(double **matrix) {
    free(matrix);
}

double abs_double(double value) {
    if (value < 0.0) {
        value = -value;
    }
    return value;
}

void swap_rows(double **matrix, int first, int second) {
    double *temp = matrix[first];
    matrix[first] = matrix[second];
    matrix[second] = temp;
}
Задание 8
#include <stdio.h>
#include <stdlib.h>

#define EPS 0.0000001

int invert(double **matrix, int n, double **result);
int input(double ***matrix, int *n, int *m);
void output(double **matrix, int n, int m);
double **allocate_matrix(int n, int m);
void free_matrix(double **matrix);
double abs_double(double value);
void swap_rows(double **matrix, int first, int second);

int main(void) {
    double **matrix = NULL;
    double **result = NULL;
    int n;
    int m;
    int error = 0;

    if (input(&matrix, &n, &m) == 0 || n != m) {
        error = 1;
    } else {
        result = allocate_matrix(n, n);
        if (result == NULL || invert(matrix, n, result) == 0) {
            error = 1;
        }
    }

    if (error == 1) {
        printf("n/a");
    } else {
        output(result, n, n);
    }

    free_matrix(matrix);
    free_matrix(result);
    return 0;
}

int invert(double **matrix, int n, double **result) {
    int success = 1;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            result[i][j] = 0.0;
        }
        result[i][i] = 1.0;
    }

    for (int i = 0; i < n && success == 1; i++) {
        int pivot = i;
        for (int j = i + 1; j < n; j++) {
            if (abs_double(matrix[j][i]) > abs_double(matrix[pivot][i])) {
                pivot = j;
            }
        }

        if (abs_double(matrix[pivot][i]) < EPS) {
            success = 0;
        } else {
            if (pivot != i) {
                swap_rows(matrix, pivot, i);
                swap_rows(result, pivot, i);
            }

            double divider = matrix[i][i];
            for (int j = 0; j < n; j++) {
                matrix[i][j] /= divider;
                result[i][j] /= divider;
            }

            for (int row = 0; row < n; row++) {
                if (row != i) {
                    double factor = matrix[row][i];
                    for (int col = 0; col < n; col++) {
                        matrix[row][col] -= factor * matrix[i][col];
                        result[row][col] -= factor * result[i][col];
                    }
                }
            }
        }
    }

    return success;
}

int input(double ***matrix, int *n, int *m) {
    int success = 1;

    if (scanf("%d %d", n, m) != 2 || *n <= 0 || *m <= 0) {
        success = 0;
    } else {
        *matrix = allocate_matrix(*n, *m);
        if (*matrix == NULL) {
            success = 0;
        } else {
            for (int i = 0; i < *n; i++) {
                for (int j = 0; j < *m; j++) {
                    if (scanf("%lf", &(*matrix)[i][j]) != 1) {
                        success = 0;
                    }
                }
            }
        }
    }

    return success;
}

void output(double **matrix, int n, int m) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (j > 0) {
                printf(" ");
            }
            if (abs_double(matrix[i][j]) < EPS) {
                matrix[i][j] = 0.0;
            }
            printf("%.6lf", matrix[i][j]);
        }
        if (i < n - 1) {
            printf("\n");
        }
    }
}

double **allocate_matrix(int n, int m) {
    double **matrix = malloc(n * sizeof(double *) + n * m * sizeof(double));

    if (matrix != NULL) {
        double *data = (double *)(matrix + n);
        for (int i = 0; i < n; i++) {
            matrix[i] = data + i * m;
        }
    }

    return matrix;
}

void free_matrix(double **matrix) {
    free(matrix);
}

double abs_double(double value) {
    if (value < 0.0) {
        value = -value;
    }
    return value;
}

void swap_rows(double **matrix, int first, int second) {
    double *temp = matrix[first];
    matrix[first] = matrix[second];
    matrix[second] = temp;
}