// CCC 2009
//
// S5: Wireless   V2     The better version :-)
//
// This algorithm is by Brian Bi of Woburn Collegiate Institute
//
// Amlesh Jayakumar and Daniel Galperin of Waterloo Collegiate Institute
// also came up with the same idea.
//  
// Here is the idea.
//
// Suppose you have an array x with values:
//      6 3 9 12 13 5 3
// stored in locations 0 to 6
//
// There is an alternate way to store these values: AS DIFFERENCES
// For example the above could be stored as
//      6 -3 6 3 1 -8 -2
// the idea is that element 0 is the normal value
// but for all the rest, the ith value is x[i] - x[i-1]
//
// Why do this? Because its very easy to add a value to
// a subset of the array with ONLY 2 assignments! 
//
// For example in the above, suppose we wanted to add 4 to the values
// of x from element 2 to 5. All we have to do is ADD 4 to element 2
// AND SUBTRACT 4 from element 6. Getting
//      6 -3 10 3 1 -8 -6
//
// To see that this is correct, expand it back out:
//      6 3 13 16 17 9 3
// TA DA! (4 was added to elements 2 thru 5)
//
// So in a sense this method works like my original solution, BUT mine
// took FOREVER to add the bitrate to ALL the values, this improves things 
// HUGE by just adding (or subtracting) the bitrate at the ends.
//
// Amlesh and Daniel described this method as adding the bitrate to the 
// left side of the cirle and subtracting the bitrate from the right side. 
// Exactly the same thing. 
//


import java.awt.*;
import hsa.*;

public class CCC2009S5WirelessV2
{
    static Console c;

    public static void main (String[] args)
    {
	c = new Console ();
	TextInputFile f = new TextInputFile ("s5.5.in");

	// diff[0][c] holds the running total at row 0 and column c;
	// diff[r][c] where r>0 holds the difference
	// between the running totals at (row r,column c) and (row r-1,column c).
	int[] [] diff;

	int cols, rows, col, row, radius, bitrate, left, right;
	rows = f.readInt ();
	cols = f.readInt ();
	diff = new int [rows+1] [cols+1];

	for (int i = 0 ; i <= rows ; i++)
	    for (int j = 0 ; j <= cols ; j++)
		diff [i] [j] = 0;

	int k = f.readInt ();
	for (int i = 0 ; i < k ; i++)
	{
	    col = f.readInt ();
	    row = f.readInt ();
	    radius = f.readInt ();
	    bitrate = f.readInt ();

	    row--; 
	    col--; //for zero-based indices
	    
	    //range of columns covered: the circle extends a number of columns in each direction equal to its radius,
	    //but if it goes beyond the boundaries, then we don't consider those outside slices.
	    for (int j = Math.max (0, col - radius) ; j <= Math.min (cols - 1, col + radius) ; j++)
	    {
		// from the equation of the circle we calculate 
		// left, the first row in this column covered by this circle
		// right, the last row in this column covered by this circle.
		left = Math.max (0, row - (int) Math.sqrt (radius * radius - (col - j) * (col - j)));
		right = Math.min (rows - 1, row + (int) Math.sqrt (radius * radius - (col - j) * (col - j)));
		diff [left] [j] += bitrate;
		diff [right + 1] [j] -= bitrate;
	    }
	}
	int best = 0;
	int count = 0;
	for (int i = 0 ; i < rows ; i++)
	    for (int j = 0 ; j < cols ; j++)
	    {
		//calculate the actual bitrate at (i,j) by adding
		if (i > 0)
		    diff [i] [j] += diff [i - 1] [j]; 
		if (diff [i] [j] == best)
		    count++;
		if (diff [i] [j] > best)
		{
		    best = diff [i] [j];
		    count = 1;
		}
	    }
	c.println (best + "\n" + count);
    }
}