#include <bits/stdc++.h>

using namespace std;

//#define FILE_IO

typedef pair<int, int> pii;
typedef long double LD;

const LD eps = 1e-9;
const int cx[] = {-1, 1, 0, 0};
const int cy[] = {0, 0, -1, 1};

LD ans, dp[2][25][25];
pii per[25][25];
int tnl[25][25];
int N, M, K;
char a[25][25];
int vec[25][25];
int f[25][25];
int pzz[25][25];

vector <pii> pos, bmb, ext;

class Gauss
{
public:
    const LD eps = 1e-9;
    int N, M;
    vector < vector<LD> > g;
    vector <LD> ans;
    int ok;

    Gauss() {N = M = 0;}
    Gauss(int _N, int _M)
    {
        N = _N, M = _M;
        g.resize(N + 5);
        for(int i = 0; i < g.size(); i++)   g[i].resize(M + 5);
        ans.resize(M + 5);
    }

    void solve()
    {
        ok = 1;
        vector <int> p(N + 5);
        for(int i = 0; i < N; i++)
        {
            for(p[i] = 0; p[i] <= M && fabs(g[i][ p[i] ]) <= eps; p[i]++);

            if(p[i] == M) {ok = 0; return;}
            if(p[i] == M + 1)   continue;

            for(int j = 0; j < N; j++)
                if( fabs(g[j][ p[i] ]) > eps && i != j )
                {
                    LD rap = -(g[j][ p[i] ] / g[i][ p[i] ]);
                    for(int k = 0; k <= M; k++)
                        g[j][k] += g[i][k] * rap;
                }
        }

        for(int i = 0; i < M; i++)  ans[i] = 0.0;
        for(int i = 0; i < N; i++)
            if(p[i] < M)
                ans[ p[i] ] = g[i][M] / g[i][ p[i] ];
    }
};

void DFS(int x, int y)
{
    if(f[x][y]) return;
    f[x][y] = 1;

    if(tnl[x][y])
    {
        pii a = per[x][y];
        x = a.first, y = a.second;
    }

    for(int i = 0; i < 4; i++)
    {
        int nx = x + cx[i];
        int ny = y + cy[i];

        if(a[nx][ny] == 'O')
            DFS(nx, ny);
        else if(a[nx][ny] == '%' || a[nx][ny] == '*')   f[nx][ny] = 1;
    }
}

int main()
{
    #ifdef FILE_IO
    freopen("1.in", "r", stdin);
    freopen("1.out", "w", stdout);
    #endif

    scanf("%d%d%d\n", &N, &M, &K);
    for(int i = 1; i <= N; i++)
        gets(a[i] + 1);
    for(int i = 1; i <= K; i++)
    {
        int a1, b1, a2, b2;
        cin >> a1 >> b1 >> a2 >> b2;
        per[a1][b1] = {a2, b2};
        per[a2][b2] = {a1, b1};
        tnl[a1][b1] = tnl[a2][b2] = 1;
    }

    int xs = 0, ys = 0;
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= M; j++)
        {
            if(a[i][j] == 'A') { a[i][j] = 'O'; xs = i, ys = j; }
            if(a[i][j] == 'O')
            {
                for(int k = 0; k < 4; k++)
                {
                    char ch = a[i + cx[k]][j + cy[k]];
                    if(ch == 'O' || ch == '*' || ch == '%')  vec[i][j]++;
                }
            }
        }

    DFS(xs, ys);

    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= M; j++)
        {
            if(a[i][j] == 'O')
            {
                if(!f[i][j])    continue;
                else if(f[i][j] && tnl[i][j] && !f[ per[i][j].first ][ per[i][j].second ])
                {
                    a[i][j] = '*';
                    bmb.push_back({i, j});
                    pzz[i][j] = bmb.size() - 1;
                }
                else    if(f[i][j])    pos.push_back({i, j}), pzz[i][j] = pos.size() - 1;
            }
            else if(a[i][j] == '*')
            {
                if(f[i][j]) bmb.push_back({i, j}), pzz[i][j] = bmb.size() - 1;
            }
            else if(a[i][j] == '%')
            {
                if(f[i][j]) ext.push_back({i, j}), pzz[i][j] = ext.size() - 1;
            }
        }

    if(ext.empty()) { cout << fixed << setprecision(10) << 0.0; return 0; }
    int C = pos.size() + bmb.size() + ext.size();
    int L = C + 1;
    if( bmb.empty() ) { cout << fixed << setprecision(10) << 1.0; return 0; }

    Gauss gss(L, C);
    /// ext , bmb , pos
    int EXT = ext.size() ,BMB = bmb.size(), POS = pos.size();
    for(int i = 0; i < EXT; i++)
    {
        gss.g[0][i] = 1.0;
        gss.g[1 + i][i] = -1.0;
    }
    for(int i = 0; i < BMB; i++)
    {
        gss.g[0][i + EXT] = 1.0;
        gss.g[1 + EXT + i][i + EXT] = -1.0;
    }
    for(int i = 0; i < POS; i++)
        gss.g[1 + EXT + BMB + i][EXT + BMB + i] = -1.0;
    gss.g[0][C] = 1.0;

    for(int i = 0; i < pos.size(); i++)
    {
        int x = pos[i].first;
        int y = pos[i].second;

        int nx = x, ny = y;
        if(tnl[x][y])
        {
            nx = per[x][y].first;
            ny = per[x][y].second;
        }

        LD rap = 1.0 / (LD)vec[x][y];
        int ps = i + EXT + BMB;

        for(int j = 0; j < 4; j++)
        {
            int ux = nx + cx[j];
            int uy = ny + cy[j];

            if(a[ux][uy] == 'O')
            {
                int nxtid = pzz[ux][uy] + BMB + EXT + 1;
                gss.g[nxtid][ps] = rap;
            }
            else if(a[ux][uy] == '*')
            {
                int nxtid = pzz[ux][uy] + EXT + 1;
                gss.g[nxtid][ps] = rap;
            }
            else if(a[ux][uy] == '%')
            {
                int nxtid = pzz[ux][uy] + 1;
                gss.g[nxtid][ps] = rap;
            }
        }
    }

    for(int i = 0; i < pos.size(); i++)
    {
        if(pos[i].first == xs && pos[i].second == ys)
        {
            int id = i + EXT + BMB;
            gss.g[id].clear();
            gss.g[id + 1][id] = 1.0;
            gss.g[id + 1][C] = 1.0;
        }
    }

    gss.solve();
    if(!gss.ok) { cout << fixed << setprecision(10) << 0.0; return 0; }

    LD ans = 0.0;
    for(int i = 0; i < ext.size(); i++)
        ans += gss.ans[i];
    cout << fixed << setprecision(10) << ans;


    return 0;
}