#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

//Debug Template:
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif

//#define int long long

//Random Number Generator:
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x^(x>>30))*0xbf58476d1ce4e5b9;
        x = (x^(x>>27))*0x94d049bb133111eb;
        return x^(x>>31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = rng();
        return splitmix64(x+FIXED_RANDOM);
    }
};

//Custom Data Structures:
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T> using safe_set = unordered_set<T, custom_hash>;
template<typename T, typename V> using safe_map = unordered_map<T, V, custom_hash>;
template<typename T> using vc = vector<T>; template<typename T> using vvc = vc<vc<T>>; template<typename T> using vvvc = vc<vvc<T>>;
template<typename T, int V> using ar = array<T, V>;
template<typename T, typename V> using pr = pair<T, V>;
using vi = vc<int>; using vvi = vvc<int>; using vvvi = vvvc<int>;
using pii = pr<int, int>;

//Macros:
#define repl(i, a, b) for(int i = a; i < b; ++i)
#define repe(i, a, b) for(int i = a; i <= b; ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define pow(b, p) (int)pow(b, p)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fir first
#define sec second
#define lsb(x) (int)__builtin_ctzll(x)
#define msb(x) (int)(63-__builtin_clzll(x))
#define yes cout << "YES\n"
#define no cout << "NO\n"

#define readall(x) trav(it, x) cin >> it;
#define printall(x) trav(it, x) cout << it << " ";
#define getmin(x) *min_element(all(x))
#define getmax(x) *max_element(all(x))

//c Problem Info:
const int MAX_N = 200005;
const int MAX_M = 200005;
const int INF = 1000000000;
const int MOD = pow(2, 64);

void solve() {
    int n, m, k;
    cin >> n >> m >> k;

    //represents if some square is a snake and also represents distance+1 from head;
    vvi org_snake(n+1, vi(m+1, 0));
    int hx = 0, hy = 0;
    repe(i, 1, k) {
        int x, y;
        cin >> x >> y;

        if (i == 1) hx = x, hy = y;
        org_snake[x][y] = i;
    }

    vvc<char> grid(n+1, vc<char>(m+1));
    repe(i, 1, n) {
        repe(j, 1, m) cin >> grid[i][j];
    }

    vvi dist(n+1, vi(m+1, INF));
    int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
    priority_queue<ar<int, 4>, vc<ar<int, 4>>, greater<>> pq;
    //pre-initialize the head of the snake;
    dist[hx][hy] = 0;
    pq.push({0, 0, hx, hy});
    while (!pq.empty()) {
        auto [csteps, hasremoved, cx, cy] = pq.top();
        pq.pop();
        //transition to next locations, up, down, left, right;
        repl(i, 0, 4) {
            int nx = cx+dx[i], ny = cy+dy[i];

            if (nx < 1 || nx > n || ny < 1 || ny > m || dist[nx][ny] != INF || grid[nx][ny] == '#') continue;
            if (org_snake[nx][ny] != 0) {
                //check to see if the head will hit the body;
                int steps_needed = k-org_snake[nx][ny]-csteps;
                if (steps_needed > 0) {
                    //if already removed, then we don't need to worry about this;
                    if (hasremoved) {
                        dist[nx][ny] = csteps+1;
                        pq.push({csteps+1, 1, nx, ny});
                    } else {
                        //we will wait the necessary # of steps;
                        dist[nx][ny] = csteps+1+steps_needed;
                        pq.push({csteps+1+steps_needed, 1, nx, ny});
                    }
                } else {
                    dist[nx][ny] = csteps+1;
                    pq.push({csteps+1, hasremoved, nx, ny});
                }
            } else {
                dist[nx][ny] = csteps+1;
                pq.push({csteps+1, hasremoved, nx, ny});
            }
        }
    }

    /*int mtime = n+m+k;
    vvc<pii> process(mtime+1);
    process[0].pb({hx, hy});
    dist[hx][hy] = 0;
    repe(t, 0, mtime) {
        for (auto &[cx, cy] : process[t]) {
            if (dist[cx][cy] < t) continue;
            //transition to next locations, up, down, left, right;
            repl(i, 0, 4) {
                int nx = cx+dx[i], ny = cy+dy[i];
                if (nx < 1 || nx > n || ny < 1 || ny > m || dist[nx][ny] != INF || grid[nx][ny] == '#') continue;
                if (org_snake[nx][ny] != 0) {
                    //check to see if the head will hit the body;
                    int steps_needed = k-org_snake[nx][ny]-t;
                    if (steps_needed > 0) {
                        dist[nx][ny] = t+1+steps_needed;
                        process[t+1+steps_needed].pb({nx, ny});
                    } else {
                        dist[nx][ny] = t+1;
                        process[t+1].pb({nx, ny});
                    }
                } else {
                    dist[nx][ny] = t+1;
                    process[t+1].pb({nx, ny});
                }
            }
        }
    }*/

    __int128_t ans = 0, mod = 2;
    repe(i, 1, 63) mod *= 2;
    repe(i, 1, n) {
        repe(j, 1, m) {
            if (dist[i][j] != INF) {
                ans = (ans+__int128_t(dist[i][j])*__int128_t(dist[i][j])%mod)%mod;
            }
        }
    }

    //debug(dist);
    cout << uint64_t(ans) << "\n";
}

int main() {
    cin.tie(0)->sync_with_stdio(0);
    int t = 1;
    //cin >> t;

    while(t--) {
        solve();
    }

    return 0;
}