do высвечивается ркасным и пишет expected a declaration

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <omp.h> //чтобы распараллелить

#define MATRIX_SIZE 5
#define KERNEL_SIZE 3
#define BENCH_MAXITER 1000  // Количество итераций для бенчмарка

void scalarConv(int **matrix, int **kernel, int **result, size_t size, size_t k_size){
    size_t offset = k_size / 2;  // смещение для определения области свертки

    // Проходим по всем центральным элементам исходной матрицы
    for (size_t i = offset; i < size - offset; i++){
        for (size_t j = offset; j < size - offset; j++){
            int sum = 0;

            // Проходим по каждому элементу ядра
            for (size_t ki = 0; ki < k_size; ki++){
                for (size_t kj = 0; kj < k_size; kj++){
                    int matrix_val = matrix[i - offset + ki][j - offset +kj];
                    int kernel_val = kernel[ki][kj];
                    sum += matrix_val * kernel_val;
                }
            }
            result[i][j] = sum;
        }
    }
}
void vectorConv(int **matrix, int **kernel, int **result, size_t size, size_t k_size) {
    size_t offset = k_size / 2;
    #pragma omp parallel for collapse(2)
    for (size_t i = offset; i < size - offset; ++i) {
        for (size_t j = offset; j < size - offset; ++j) {
            int sum = 0;
            for (size_t ki = 0; ki < k_size; ++ki) {
                for (size_t kj = 0; kj < k_size; ++kj) {
                    sum += matrix[i - offset + ki][j - offset + kj] * kernel[ki][kj];
                }
            }
            result[i][j] = sum;
        }
    }
}
int **createMatrix(int size, int value){
    int** matrix = (int **)malloc(size * sizeof(int *));
    
    for (size_t i = 0; i < size ; i++){
        matrix[i] = (int *)malloc(size * sizeof(int));
        for (size_t j = 0; j < size; j++){
            matrix[i][j] = value;
        }
    }
    return matrix;
}

// Освобождение памяти
void freeMatrix(int **matrix, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        free(matrix[i]);
    }
    free(matrix);
}

double bench_baseline = 0.0;

// Макрос для бенчмаркинга
#define BENCH(func, baseline)                                                               
    do                                                                                    
    {                                                                                       
        struct timespec start, end;                                                         
        clock_gettime(CLOCK_MONOTONIC, &start);                                             
        for (int iter = 0; iter < BENCH_MAXITER; iter++)                                    
        {                                                                                   
            func;                                                                           
        }                                                                                   
        clock_gettime(CLOCK_MONOTONIC, &end);                                               
        long total_ns = get_elapsed_time_ns(start, end);                                    
        double mean = total_ns / (double)BENCH_MAXITER;                                     
        if (baseline)                                                                       
            bench_baseline = mean;                                                          
        printf("%s mean: %f.1 ns (%.2fx)\n", NAMEOF(func), mean, mean / bench_baseline);           
    } while (0)

// Функция для вычисления времени в наносекундах
double get_elapsed_time_ns(struct timespec start, struct timespec end)
{
    return (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
}

int main() {
    int **matrix = createMatrix(MATRIX_SIZE, 1);
    int **kernel = createMatrix(KERNEL_SIZE, 1);
    int **result = createMatrix(MATRIX_SIZE, 0);

    BENCH(scalarConv(matrix, kernel, result, MATRIX_SIZE, KERNEL_SIZE), true);
    
    BENCH(vectorConv(matrix, kernel, result, MATRIX_SIZE, KERNEL_SIZE), false);

    freeMatrix(matrix, MATRIX_SIZE);
    freeMatrix(kernel, KERNEL_SIZE);
    freeMatrix(result, MATRIX_SIZE);

    return 0;
}