#include <bits/stdc++.h>

#define u64 unsigned long long
#define PII std::pair<int, int>

int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};

struct node {
    int dis, id, cnt, len;
    bool operator < (const node &a) const {
        return dis > a.dis;
    }
};

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;
    std::vector<PII> snake(k + 1);

    for (int i = 1; i <= k; i ++) {
        std::cin >> snake[i].first >> snake[i].second;
    }

    std::vector<std::string> mp(n + 1);
    for (int i = 1; i <= n; i ++) {
        std::string s;
        std::cin >> s;
        s = ' ' + s;
        mp[i] = s;
    }

    auto getid = [&](int x, int y) -> int {
    	x --;
    	y --;
        return x * m + y + 1;
    };

    auto getpos = [&](int id) -> PII {
        return {(id - 1) / m + 1, (id - 1) % m + 1};
    };

    std::vector<std::vector<int>> Cnt(n + 1, std::vector<int>(m + 1, 0));
    auto dijkstra = [&](PII s) -> void {
        std::vector<u64> dis(n * m + 1, 1E9);
        std::vector<int> vis(n * m + 1, 0);
        std::vector<std::vector<int>> Mp(n + 1, std::vector<int>(m + 1, 1E9));
        for (int i = 1; i <= k; i ++) {
            Mp[snake[i].first][snake[i].second] = i;
        }
        // for (int i = 1; i <= n; i ++) {
        	// for (int j = 1; j <= m; j ++) std::cout << Mp[i][j] << " \n"[j == m];
        // }
        std::priority_queue<node> q;
        q.push({0, getid(s.first, s.second), 0, k});
        dis[getid(s.first, s.second)] = 0;
        while (!q.empty()) {
            auto [d, u, cnt, len] = q.top();
            q.pop();
            auto [x, y] = getpos(u);
            if (vis[u] == 1) continue;
            vis[u] = 1; 
            for (int i = 0; i < 4; i ++) {
                int nx = x + dx[i], ny = y + dy[i];
                int v = getid(nx, ny);
                if (nx < 1 || nx > n || ny < 1 || ny > m || mp[nx][ny] == '#') continue;
                if (len - Mp[nx][ny] - cnt > 0) {
                    int Len = Mp[nx][ny];
                    if (Len < 1) continue;
                    // std::cout << nx << " " << ny << " " << Len << "\n";
                    if (dis[v] > d + len - Len + 1) {
                        dis[v] = d + len - Len + 1;
                        q.push({dis[v], v, cnt + 1, Len});
                    }
                    continue;
                }
                v = getid(nx, ny);
                if (dis[v] > d + 1) {
                    dis[v] = d + 1;
                    q.push({dis[v], v, cnt + 1, len});
                }
                
            }
        }
        
        u64 Ans = 0;
        for (int i = 1; i <= n * m; i ++) {
        	auto P = getpos(i);
            Cnt[P.first][P.second] = dis[i];
            if (dis[i] == 1E9) continue;
            Ans += (dis[i]) * (dis[i]);
        }
        // for (int i = 1; i <= n; i ++) {
            // for (int j = 1; j <= m; j ++) {
                // std::cout << Cnt[i][j] << " \n"[j == m];
            // }
        // }
        std::cout << Ans << "\n";
    };

    dijkstra({snake[1].first, snake[1].second});
    
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int T = 1;
    // std::cin >> T;
    while (T --) {
        solve();
    }
}