#include <iostream>
#include <map>
#include <unordered_map>
#include <vector>
#include <string>
#include <set>
#include <algorithm>
#include <climits>

using namespace std;

struct Gosc
{
	Gosc() {};
	Gosc(unsigned int _a, unsigned int _b) : a(_a), b(_b) {}
	~Gosc() {};
	
	unsigned int a, b = 0;
};


struct Cell
{
    bool blocked = false;

    bool visited = false;
    int parent_i, parent_j = 0;
    unsigned int f, g, h = UINT_MAX;


    void Clear()
    {
        visited = false;
        parent_i = 0;
        parent_j = 0;
        f = UINT_MAX;
        g = UINT_MAX;
        h = UINT_MAX;
    }
};

unsigned int N, M, K;
Cell** MAPA = new Cell * [N];



// Creating a shortcut for int, int pair type 
typedef pair<unsigned int, unsigned int> Pair;

// Creating a shortcut for pair<int, pair<int, int>> type 
typedef pair<unsigned int, pair<unsigned int, unsigned int>> pPair;

// A structure to hold the neccesary parameters 
struct cell
{
    // Row and Column index of its parent 
    // Note that 0 <= i <= ROW-1 & 0 <= j <= COL-1 
    int parent_i, parent_j;
    // f = g + h 
    double f, g, h;
};

//cell** cellDetails = new cell* [N];

// A Utility Function to check whether given cell (row, col) 
// is a valid cell or not. 
bool isValid(int row, int col)
{
    // Returns true if row number and column number 
    // is in range 
    return (row >= 0) && (row < N) &&
        (col >= 0) && (col < M);
}

// A Utility Function to check whether the given cell is 
// blocked or not 
bool isUnBlocked(int row, int col)
{
    // Returns true if the cell is not blocked else false 
    if (MAPA[row][col].blocked)
        return (false);
    else
        return (true);
}

// A Utility Function to check whether destination cell has 
// been reached or not 
bool isDestination(int row, int col)
{
    if (row == N-1 && col == M-1)
        return (true);
    else
        return (false);
}

// A Utility Function to calculate the 'h' heuristics. 
unsigned int calculateHValue(int row, int col)
{
    return (N - 1 - row) + (M - 1 - col);
}

unsigned int calculateGValue(int row, int col, int parent_row, int parent_col, const Gosc& g)
{
    if (row > parent_row || col > parent_col)
    {
        return g.a;
    }
    else
    {
        return g.b;
    }
}

bool aStarSearch(Pair src, Pair dest, const Gosc& gosc)
{
  

	int i, j;
	i = src.first, j = src.second;

    MAPA[i][j].f = 0.0;
    MAPA[i][j].g = 0.0;
    MAPA[i][j].h = 0.0;
    MAPA[i][j].parent_i = i;
    MAPA[i][j].parent_j = j;

	if (isDestination(src.first, src.second) == true)
	{
		return true;
	}

    set<pPair> openList;

    // Put the starting cell on the open list and set its 
    // 'f' as 0 
    openList.insert(make_pair(0.0, make_pair(0, 0)));

    // We set this boolean value as false as initially 
    // the destination is not reached. 
    bool foundDest = false;

    while (!openList.empty())
    {
        pPair p = *openList.begin();

        // Remove this vertex from the open list 
        openList.erase(openList.begin());

        // Add this vertex to the closed list 
        i = p.second.first;
        j = p.second.second;
        MAPA[i][j].visited = true;


         // To store the 'g', 'h' and 'f' of the 8 successors 
        unsigned int gNew, hNew, fNew;

        //----------- 1st Successor (North) ------------ 

        // Only process this cell if this is a valid one 
        if (isValid(i - 1, j) == true)
        {
            // If the destination cell is the same as the 
            // current successor 
            if (isDestination(i - 1, j) == true)
            {
                // Set the Parent of the destination cell 
                MAPA[i - 1][j].parent_i = i;
                MAPA[i - 1][j].parent_j = j;
                foundDest = true;
                MAPA[i - 1][j].g = calculateGValue(i - 1, j, i, j, gosc);
                return true;
            }
            // If the successor is already on the closed 
            // list or if it is blocked, then ignore it. 
            // Else do the following 
            else if (MAPA[i - 1][j].visited == false &&
                isUnBlocked(i - 1, j) == true)
            {
                gNew = calculateGValue(i - 1, j, i, j, gosc);
                hNew = calculateHValue(i - 1, j);
                fNew = gNew + hNew;

                if (MAPA[i - 1][j].f == UINT_MAX ||
                    MAPA[i - 1][j].f > fNew)
                {
                    openList.insert(make_pair(fNew,
                        make_pair(i - 1, j)));

                    // Update the details of this cell 
                    MAPA[i - 1][j].f = fNew;
                    MAPA[i - 1][j].g = gNew;
                    MAPA[i - 1][j].h = hNew;
                    MAPA[i - 1][j].parent_i = i;
                    MAPA[i - 1][j].parent_j = j;
                }
            }
        }

        //----------- 2nd Successor (South) ------------ 

        // Only process this cell if this is a valid one 
        if (isValid(i + 1, j) == true)
        {
            // If the destination cell is the same as the 
            // current successor 
            if (isDestination(i + 1, j) == true)
            {
                // Set the Parent of the destination cell 
                MAPA[i + 1][j].parent_i = i;
                MAPA[i + 1][j].parent_j = j;
           //     printf("The destination cell is found\n");
            //    tracePath(cellDetails, dest);
                foundDest = true;
                MAPA[i + 1][j].g = calculateGValue(i + 1, j, i, j, gosc);
                return true;
            }
            // If the successor is already on the closed 
            // list or if it is blocked, then ignore it. 
            // Else do the following 
            else if (MAPA[i + 1][j].visited == false &&
                isUnBlocked(i + 1, j) == true)
            {
                gNew = calculateGValue(i + 1, j, i, j, gosc);
                hNew = calculateHValue(i + 1, j);
                fNew = gNew + hNew;

                if (MAPA[i + 1][j].f == UINT_MAX ||
                    MAPA[i + 1][j].f > fNew)
                {
                    openList.insert(make_pair(fNew, make_pair(i + 1, j)));
                    // Update the details of this cell 
                    MAPA[i + 1][j].f = fNew;
                    MAPA[i + 1][j].g = gNew;
                    MAPA[i + 1][j].h = hNew;
                    MAPA[i + 1][j].parent_i = i;
                    MAPA[i + 1][j].parent_j = j;
                }
            }
        }

        //----------- 3rd Successor (East) ------------ 

        // Only process this cell if this is a valid one 
        if (isValid(i, j + 1) == true)
        {
            // If the destination cell is the same as the 
            // current successor 
            if (isDestination(i, j + 1) == true)
            {
                // Set the Parent of the destination cell 
                MAPA[i][j + 1].parent_i = i;
                MAPA[i][j + 1].parent_j = j;
                //printf("The destination cell is found\n");
             //   tracePath(cellDetails, dest);
                foundDest = true;
                MAPA[i][j+1].g = calculateGValue(i, j+1, i, j, gosc);
                return true;
            }

            // If the successor is already on the closed 
            // list or if it is blocked, then ignore it. 
            // Else do the following 
            else if (MAPA[i][j + 1].visited == false &&
                isUnBlocked(i, j + 1) == true)
            {
                gNew = calculateGValue(i, j + 1, i, j, gosc);
                hNew = calculateHValue(i, j + 1);
                fNew = gNew + hNew;

                if (MAPA[i][j + 1].f == UINT_MAX ||
                    MAPA[i][j + 1].f > fNew)
                {
                    openList.insert(make_pair(fNew,
                        make_pair(i, j + 1)));

                    // Update the details of this cell 
                    MAPA[i][j + 1].f = fNew;
                    MAPA[i][j + 1].g = gNew;
                    MAPA[i][j + 1].h = hNew;
                    MAPA[i][j + 1].parent_i = i;
                    MAPA[i][j + 1].parent_j = j;
                }
            }
        }

        //----------- 4th Successor (West) ------------ 

        // Only process this cell if this is a valid one 
        if (isValid(i, j - 1) == true)
        {
            // If the destination cell is the same as the 
            // current successor 
            if (isDestination(i, j - 1) == true)
            {
                // Set the Parent of the destination cell 
                MAPA[i][j - 1].parent_i = i;
                MAPA[i][j - 1].parent_j = j;
                foundDest = true;
                MAPA[i][j-1].g = calculateGValue(i, j - 1, i, j, gosc);
                return true;
            }

            else if (MAPA[i][j - 1].visited == false &&
                isUnBlocked(i, j - 1) == true)
            {
                gNew = calculateGValue(i, j - 1, i, j, gosc);
                hNew = calculateHValue(i, j - 1);
                fNew = gNew + hNew;

                if (MAPA[i][j - 1].f == UINT_MAX ||
                    MAPA[i][j - 1].f > fNew)
                {
                    openList.insert(make_pair(fNew,
                        make_pair(i, j - 1)));

                    // Update the details of this cell 
                    MAPA[i][j - 1].f = fNew;
                    MAPA[i][j - 1].g = gNew;
                    MAPA[i][j - 1].h = hNew;
                    MAPA[i][j - 1].parent_i = i;
                    MAPA[i][j - 1].parent_j = j;
                }
            }
        }

    }

    return false;
}


unsigned int FindShortestPath()
{
    //calculate cost
    unsigned int cost = 0;
    unsigned int i = N - 1;
    unsigned int j = M - 1;

    do 
    {
        cost += MAPA[i][j].g;
        unsigned int newI = 0;
        unsigned int newJ = 0;
        newI = MAPA[i][j].parent_i;
        newJ = MAPA[i][j].parent_j;
        i = newI;
        j = newJ;

    } while (i != 0 || j != 0);

	return cost;
}


int main()
{
	cin >> N;
	cin >> M;
	cin >> K;

	for (unsigned int i = 0; i < N; ++i)
	{
		MAPA[i] = new Cell[M];
	}

	char c;

	for (unsigned int i = 0; i < N; ++i)
	{
		for (unsigned int j = 0; j < M; ++j)
		{
			cin >> c;
			if (c == '.')
			{
				MAPA[i][j].blocked = false;
			}
			else
			{
				MAPA[i][j].blocked = true;
			}
		}
	}

	unsigned int shortest_path = UINT_MAX;
	unsigned int shortest_path_num = 0;

	for (unsigned int i = 0; i < K; ++i)
	{
		// wyczysc mape
		for (unsigned int i = 0; i < N; ++i)
		{
			for (unsigned int j = 0; j < M; ++j)
			{
				MAPA[i][j].Clear();
			}
		}

		Gosc g;
		cin >> g.a >> g.b;

        // znajdz sciezke
		bool res = aStarSearch(make_pair(0, 0), make_pair(N, M), g);


        if (!res)
        {
            continue;
        }

        // oblicz dlugosc
		unsigned int path = FindShortestPath();

		if (path == shortest_path)
		{
			++shortest_path_num;
		}

		if (path < shortest_path)
		{
			shortest_path = path;
			shortest_path_num = 1;
		}
	}

	cout << shortest_path << " " << shortest_path_num;



	for (int i = 0; i < N; ++i) {
		delete[] MAPA[i];
	}


	return 0;
}