#include <iostream>
#include <map>
#include <ios>

int main()
{
	std::map<long long int, int> abstract_map;


	int matrix_size = 0;
	long long int submatrix_count = 0;
	int number = 0;

	long long int submatrix_row_1 = 0;
	long long int submatrix_row_2 = 0;
	long long int submatrix_column_1 = 0;
	long long int submatrix_column_2 = 0;
	long long int current_submatrix_elements_sum = 0;
	long long int submatrixes_elements_sum = 0;

    std::ios::sync_with_stdio(false);

	std::cin >> matrix_size;
	std::cin >> submatrix_count;
	int** matrix = new int*[matrix_size + 1];

	for(register int matrix_row = 0; matrix_row < matrix_size + 1; matrix_row++)
	{
		matrix[matrix_row] = new int[matrix_size + 1];
	}

	for(register int matrix_row = 0; matrix_row < matrix_size + 1; matrix_row++)
	{
		matrix[matrix_row][0] = 0;
	}

	for(register int matrix_column = 0; matrix_column < matrix_size + 1; matrix_column++)
	{
		matrix[0][matrix_column]= 0;
	}

	for(register int matrix_row = 1; matrix_row < matrix_size + 1; matrix_row++)
	{
		matrix[matrix_row][0] = matrix[0][matrix_row]= 0;
		for(register int matrix_column = 1; matrix_column < matrix_size + 1; matrix_column++)
		{
			std::cin >> number;
			matrix[matrix_row][matrix_column] = number + matrix[matrix_row][matrix_column - 1] + matrix[matrix_row - 1][matrix_column] - matrix[matrix_row - 1][matrix_column - 1];
		}
	}
	for(register int submatrix = 0; submatrix < submatrix_count; submatrix++)
	{
		std::cin >> submatrix_row_1;
		std::cin >> submatrix_column_1;
		std::cin >> submatrix_row_2;
		std::cin >> submatrix_column_2;
	
		current_submatrix_elements_sum = matrix[submatrix_row_2 + 1][submatrix_column_2 + 1] - matrix[submatrix_row_2 + 1][submatrix_column_1] - matrix[submatrix_row_1][submatrix_column_2 + 1] + matrix[submatrix_row_1][submatrix_column_1];
	
		submatrixes_elements_sum += current_submatrix_elements_sum;

		abstract_map[current_submatrix_elements_sum]++;
	}

	long long int max_abstract = 0;
	int max_abstract_count = 0;

	for(std::map<long long int, int>::iterator map_iterator = abstract_map.begin(); map_iterator != abstract_map.end(); map_iterator++)
	{
		if(map_iterator->second == max_abstract)
		{
			max_abstract_count++;
		}
		else if(map_iterator->second > max_abstract){
			max_abstract_count = 1;
			max_abstract = map_iterator->second;
		}
	}

	std::cout << abstract_map.size() << " " << max_abstract_count << " " << submatrixes_elements_sum / submatrix_count;

	return 0;
}