#include <iostream>
#include <string>
#include <queue>
#include <map>
#include <limits>

using namespace std;

const long long INFINITY = numeric_limits<long long>::max();
const long long PRIME = 1000000007LL;

int field_id(int row, int col, int row_size) {
    return row * row_size + col;
}

long long player_id(long long costA, long long costB) {
    return costA * PRIME + costB;
}

int mapGoLeft(int fieldId, int columns) { //return field id for going left on map
    int result = fieldId - 1;
    if (result % columns == columns - 1) { //illegal
        return -1;
    }
    return result;
}

int mapGoRight(int fieldId, int columns) { //return field id for going right on map
    int result = fieldId + 1;
    if (result % columns == 0) { //illegal
        return -1;
    }
    return result;
}

int mapGoUp(int fieldId, int columns) { //return field id for going up on map
    int result = fieldId - columns;
    if (result < 0) { //illegal
        return -1;
    }
    return result;
}

int mapGoDown(int fieldId, int rows, int columns) { //return field id for going down on map
    int result = fieldId + columns;
    if (result >= rows * columns) { //illegal
        return -1;
    }
    return result;
}

long long dijkstra(int start_field, int end_field, bool* fields, int rows, int columns, long long costIncH, long long costDecH) {
    int size = rows * columns;
    long long* dist = new long long[size];
    // int* prev = new int[size];
    // bool* visited = new bool[size];

    priority_queue<pair<long long, int> > Q;

    for (int v = 0; v < size; ++v) {
        dist[v] = INFINITY;
        // prev[v] = -1;
        // visited[v] = false;
    }
    
    dist[start_field] = 0;

    for (int v = 0; v < size; ++v) {
        Q.push(make_pair(-dist[v], v));
    }

    int current = -1;
    int neighbour = -1;
    long long newDistance = -1;

    bool stop = false;
    while (!stop && !Q.empty()) {
        current = Q.top().second;
        Q.pop();

        // if (visited[current]) {
        //     // cleaning Q from outdated vertex priorities
        //     continue;
        // }
       
        // visited[current] = true;
        if (current == end_field) {
            // at target
            stop = true;
            continue;
        }
        //to up
        neighbour = mapGoUp(current, columns);
        if (neighbour >= 0 && fields[neighbour]) {
            newDistance = dist[current] + costDecH;
            if (newDistance < dist[neighbour]) {
                dist[neighbour] = newDistance;
                // prev[neighbour] = current;
                Q.push(make_pair(-dist[neighbour], neighbour));
            }
        }
        //to right
        neighbour = mapGoRight(current, columns);
        if (neighbour >= 0 && fields[neighbour]) {
            newDistance = dist[current] + costIncH;
            // cout << "DEBUG: neigh: " << neighbour << "\n"
            //      << "       dist[curr]: " << dist[current] << "\n" 
            //      << "             cost: " << costIncH[player] << "\n"
            //      << "          newDist: " << newDistance << "\n";
            if (newDistance < dist[neighbour]) {
                dist[neighbour] = newDistance;
                // prev[neighbour] = current;
                Q.push(make_pair(-dist[neighbour], neighbour));
            }
        }
        //to down
        neighbour = mapGoDown(current, rows, columns);
        if (neighbour >= 0 && fields[neighbour]) {
            newDistance = dist[current] + costIncH;
            if (newDistance < dist[neighbour]) {
                dist[neighbour] = newDistance;
                // prev[neighbour] = current;
                Q.push(make_pair(-dist[neighbour], neighbour));
            }
        }
        //to left
        neighbour = mapGoLeft(current, columns);
        if (neighbour >= 0 && fields[neighbour]) {
            newDistance = dist[current] + costDecH;
            if (newDistance < dist[neighbour]) {
                dist[neighbour] = newDistance;
                // prev[neighbour] = current;
                Q.push(make_pair(-dist[neighbour], neighbour));
            }
        }
    }

    // for (int i = 0; i < size; ++i) {
    //     cout << "DEBUG: dist[" << i << "]=" << dist[i] << "\n";
    // }
    // cout << "DEBUG: FINAL current=" << current << "\n";

    // delete[] dist;
    // delete[] visited;

    return dist[end_field];
}

int main() {
    ios::sync_with_stdio(false);
    // cout << INFINITY;
    // cout << player_id(1000000000, 1000000000, 1000000);

    int n, m;
    long long k;
    string s;

    cin >> n >> m >> k;

    bool *fields = new bool[n * m];
    long long *costIncH = new long long[k]; //a
    long long *costDecH = new long long[k]; //b
    long long *times = new long long[k]; //destination time
    map<long long, long long> cache;
    long long min_time = INFINITY;
    int count = 0;

    int fieldId;

    for (int row = 0; row < n; ++row) {
        cin >> s;
        for (int col = 0; col < m; ++col) {
            fieldId = field_id(row, col, m);
            if (s[col] == '.') {
                fields[fieldId] = true;
            } else { // X
                fields[fieldId] = false;
            }
        }
    }

    for (long long i = 0; i < k; ++i) {
        cin >> costIncH[i] >> costDecH[i];
    }

    map<long long, long long>::iterator it;
    long long playerId;
    long long bestCostIncH = INFINITY;
    long long bestCostDecH = INFINITY;
    for (long long i = 0; i < k; ++i) {
        playerId = player_id(costIncH[i], costDecH[i]);
        // cout << "player"<<costIncH[i] << " " << costDecH[i] <<"\n";
        // cout << "playerid" << playerId << "\n";
        if (costIncH[i] > bestCostIncH && costDecH[i] > bestCostDecH) {
            // cout << "skipped" << playerId << "\n";
            continue;
        }
        it = cache.find(playerId);
        if (it != cache.end()) {
            times[i] = it->second;
            // cout << "cache"<<it->second << "\n";
        } else {
            // new computation
            times[i] = dijkstra(0, n * m - 1, fields, n, m, costIncH[i], costDecH[i]);
            // cout << "new comp"<< times[i] << "\n";
            cache[playerId] = times[i];
            if (times[i] < min_time) {
                // cout << "updated"<< min_time << " with " << times[i] << "\n";
                min_time = times[i];
                bestCostIncH = costIncH[i];
                bestCostDecH = costDecH[i];
            }
        }
    }

    for (long long i = 0; i < k; ++i) {
        if (min_time == times[i]) {
            ++count;
        }
    }

    //answer
    cout << min_time << " " << count;

    return 0;
}