#include <stdio.h>
#include <math.h>

inline float Small(float a, float b){
    return (a < b) ? a : b;
}

inline float Big(float a, float b){
    return (a > b) ? a : b;
}


void min_max_avg(float **grid, int N, int M,
                 float *min, float *max, float *avg,
                 float *col_min, float *col_max, float *col_avg,
                 float *row_min, float *row_max, float *row_avg) {

    if(N == 0 || M == 0){
        *min = INFINITY;
        *max = -INFINITY;
        *avg = NAN;
        for(int i = 0; i < N; ++i){
            row_min[i] = INFINITY;
            row_max[i] = -INFINITY;
            row_avg[i] = NAN;
        }
        for(int i = 0; i < M; ++i){
            col_min[i] = INFINITY;
            col_max[i] = -INFINITY;
            col_avg[i] = NAN;
        }
        return;
    }

    int i, j;

    float tempMin = INFINITY, tempMax = -INFINITY, tempTotal = 0;
    float rowMin1, rowMin2, rowMin3, rowMin4, rowMin5;
    float rowMax1, rowMax2, rowMax3, rowMax4, rowMax5;
    float rowAdd1, rowAdd2, rowAdd3, rowAdd4, rowAdd5;

    for(i = 0; i < M; ++i){
        col_min[i] = INFINITY;
        col_max[i] = -INFINITY;
        col_avg[i] = 0;
    }

    for(i = 0; i < N; ++i){
        rowMin1 = INFINITY, rowMin2 = INFINITY, rowMin3 = INFINITY, rowMin4 = INFINITY, rowMin5 = INFINITY;
        rowMax1 = -INFINITY, rowMax2 = -INFINITY, rowMax3 = -INFINITY, rowMax4 = -INFINITY, rowMax5 = -INFINITY;
        rowAdd1 = 0, rowAdd2 = 0, rowAdd3 = 0, rowAdd4 = 0, rowAdd5 = 0;

        for(j = 0; j + 9 < M; j += 10){
            if(grid[i][j] < grid[i][j + 1])
                rowMin1 = grid[i][j], rowMax1 = grid[i][j + 1];
            else
                rowMin1 = grid[i][j + 1], rowMax1 = grid[i][j];

            if(grid[i][j + 2] < grid[i][j + 3])
                rowMin2 = grid[i][j + 2], rowMax2 = grid[i][j + 3];
            else
                rowMin2 = grid[i][j + 3], rowMax2 = grid[i][j + 2];

            if(grid[i][j + 4] < grid[i][j + 5])
                rowMin3 = grid[i][j + 4], rowMax3 = grid[i][j + 5];
            else
                rowMin3 = grid[i][j + 5], rowMax3 = grid[i][j + 4];

            if(grid[i][j + 6] < grid[i][j + 7])
                rowMin4 = grid[i][j + 6], rowMax4 = grid[i][j + 7];
            else
                rowMin4 = grid[i][j + 7], rowMax4 = grid[i][j + 6];

            if(grid[i][j + 8] < grid[i][j + 9])
                rowMin5 = grid[i][j + 8], rowMax5 = grid[i][j + 9];
            else
                rowMin5 = grid[i][j + 9], rowMax5 = grid[i][j + 8];

            rowAdd1 = grid[i][j] + grid[i][j + 1];
            rowAdd2 = grid[i][j + 2] + grid[i][j + 3];
            rowAdd3 = grid[i][j + 4] + grid[i][j + 5];
            rowAdd4 = grid[i][j + 6] + grid[i][j + 7];
            rowAdd5 = grid[i][j + 8] + grid[i][j + 9];

            col_min[j] = Small(col_min[j], grid[i][j]);
            col_min[j + 1] = Small(col_min[j + 1], grid[i][j + 1]);
            col_min[j + 2] = Small(col_min[j + 2], grid[i][j + 2]);
            col_min[j + 3] = Small(col_min[j + 3], grid[i][j + 3]);
            col_min[j + 4] = Small(col_min[j + 4], grid[i][j + 4]);
            col_min[j + 5] = Small(col_min[j + 5], grid[i][j + 5]);
            col_min[j + 6] = Small(col_min[j + 6], grid[i][j + 6]);
            col_min[j + 7] = Small(col_min[j + 7], grid[i][j + 7]);
            col_min[j + 8] = Small(col_min[j + 8], grid[i][j + 8]);
            col_min[j + 9] = Small(col_min[j + 9], grid[i][j + 9]);

            col_max[j] = Big(col_max[j], grid[i][j]);
            col_max[j + 1] = Big(col_max[j + 1], grid[i][j + 1]);
            col_max[j + 2] = Big(col_max[j + 2], grid[i][j + 2]);
            col_max[j + 3] = Big(col_max[j + 3], grid[i][j + 3]);
            col_max[j + 4] = Big(col_max[j + 4], grid[i][j + 4]);
            col_max[j + 5] = Big(col_max[j + 5], grid[i][j + 5]);
            col_max[j + 6] = Big(col_max[j + 6], grid[i][j + 6]);
            col_max[j + 7] = Big(col_max[j + 7], grid[i][j + 7]);
            col_max[j + 8] = Big(col_max[j + 8], grid[i][j + 8]);
            col_max[j + 9] = Big(col_max[j + 9], grid[i][j + 9]);

            col_avg[j] += grid[i][j];
            col_avg[j + 1] += grid[i][j + 1];
            col_avg[j + 2] += grid[i][j + 2];
            col_avg[j + 3] += grid[i][j + 3];
            col_avg[j + 4] += grid[i][j + 4];
            col_avg[j + 5] += grid[i][j + 5];
            col_avg[j + 6] += grid[i][j + 6];
            col_avg[j + 7] += grid[i][j + 7];
            col_avg[j + 8] += grid[i][j + 8];
            col_avg[j + 9] += grid[i][j + 9];
        }

        for(; j < M; ++j){
            if(grid[i][j] < rowMin1)
                rowMin1 = grid[i][j];
            if(grid[i][j] > rowMax1)
                rowMax1 = grid[i][j];
            rowAdd1 += grid[i][j];
            col_min[j] = Small(col_min[j], grid[i][j]);
            col_max[j] = Big(col_max[j], grid[i][j]);
            col_avg[j] += grid[i][j];
        }

        rowMin1 = Small(Small(Small(rowMin1, rowMin2), Small(rowMin3, rowMin4)), rowMin5);
        row_min[i] = rowMin1;
        rowMax1 = Big(Big(Big(rowMax1, rowMax2), Big(rowMax3, rowMax4)), rowMax5);
        row_max[i] = rowMax1;
        rowAdd1 = rowAdd1 + rowAdd2 + rowAdd3 + rowAdd4 + rowAdd5;
        row_avg[i] = rowAdd1 / (float)M;

        tempMin = Small(tempMin, rowMin1);
        tempMax = Big(tempMax, rowMax1);
        tempTotal += rowAdd1;
    }

    for(i = 0; i < M; ++i){
        col_avg[i] /= (float)N;
    }

    *min = tempMin;
    *max = tempMin;
    *avg = tempTotal / (float)(N * M);
} // min_max_avg