Проверить результат умножения матриц

#include <iostream>
#include <fstream>
 
constexpr size_t MAX_SIZE = 500;
 
 
int first[MAX_SIZE][MAX_SIZE], second[MAX_SIZE][MAX_SIZE], result[MAX_SIZE][MAX_SIZE];
 
inline void get_matrix(std :: ifstream &input, const size_t DIMENSION ,int array[][MAX_SIZE]);
int main()
{
    std::ifstream input_file("in.txt");
    std::ofstream output_file("output.txt");
    int DIMENSION;
    do
    {
        input_file >> DIMENSION;
        if (!DIMENSION)
        {
            return 0;
        }
        get_matrix(input_file, DIMENSION, first);
        get_matrix(input_file, DIMENSION, second);
        get_matrix(input_file, DIMENSION, result);
 
        bool flag = true;
        for (auto counter = 0; flag && counter < DIMENSION; counter++)
        {
            for (auto detector = 0; flag && detector < DIMENSION; detector++)
            {
                auto sum = 0;
                for (auto calculator = 0; calculator < DIMENSION; calculator++)
                {
                    sum += first[counter][calculator] * second[calculator][detector];
                }
                if (sum != result[counter][detector])
                {
                    flag = false;
                }
            }
        }
        output_file << (flag ? "YES" : "NO") << std :: endl;
 
    } while (true);
}
 
void get_matrix(std::ifstream &input, const size_t DIMENSION, int array[][MAX_SIZE])
{
    for (auto counter = 0; counter < DIMENSION; counter++)
    {
        for (auto detector = 0; detector < DIMENSION; detector++)
        {
            input >> array[counter][detector];
        }
    }
}

#define _CRT_SECURE_NO_WARNINGS
 
#include <stdio.h>
#include <malloc.h>
#include <string.h>
 
void allocate_memory(int ***to_allocate, const size_t CAPACITY);
int main(void)
{
    FILE *input_file = fopen("inз.txt", "r");
    FILE *output_file = fopen("output.txt", "w");
 
 
    size_t MAX_SIZE = 500;
    int **second_array= NULL;
    int **first_array = NULL;
    int **result_array = NULL;
    allocate_memory(&second_array, MAX_SIZE);
    allocate_memory(&first_array, MAX_SIZE);
    allocate_memory(&result_array, MAX_SIZE);
    size_t QUANTITY;
    while (1)
    {
        metka : 
        fscanf(input_file,"%d", &QUANTITY);
        if (!QUANTITY)
        {
            fclose(input_file);
            fclose(output_file);
            return 0;
        }
 
 
        for (size_t counter = 0; counter < QUANTITY; counter++)
        {
            for (size_t detector = 0; detector < QUANTITY; detector++)
            {
                fscanf(input_file, "%d", &first_array[counter][detector]);
            }
        }
        print(first_array, QUANTITY);
        for (size_t counter = 0; counter < QUANTITY; counter++)
        {
            for (size_t detector = 0; detector < QUANTITY; detector++)
            {
                fscanf(input_file, "%d", &second_array[counter][detector]);
            }
        }
        for (size_t counter = 0; counter < QUANTITY; counter++)
        {
            for (size_t detector = 0; detector < QUANTITY; detector++)
            {
                fscanf(input_file, "%d", &result_array[counter][detector]);
            }
        }
        for (size_t counter = 0; counter < QUANTITY; counter++)
        {
            for (size_t detector = 0; detector < QUANTITY; detector++)
            {
                int res = 0;
                for (size_t calculator = 0; calculator < QUANTITY; calculator++)
                {
                    res += first_array[counter][calculator] * second_array[calculator][detector];
                }
                if (res != result_array[counter][detector])
                {
                    fprintf(output_file, "NO\n");
                    goto metka;
                }
            }
        }
        fprintf(output_file, "YES\n");
    }
}
 
 
void allocate_memory(int ***to_allocate, const size_t CAPACITY)
{
        *to_allocate = (int **)malloc(CAPACITY * sizeof(int*));
        for (size_t detector = 0; detector < CAPACITY; detector++)
        {
            (*to_allocate)[detector] = (int*) malloc(sizeof(int) * CAPACITY);
        }
}