#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
#include<bits/stdc++.h>
#include <cassert>
using namespace std; 
#define DEBUG(codx1) cout << '>' << #codx1 << ':' << codx1 << endl;
#define REP(i,n) for(int i=0;i<(n);i++)
#define FOR(i,vecc2,b) for(int i=(vecc2);i<=(b);i++)
#define FORD(i,vecc2,b) for(int i=(vecc2);i>=(b);i--)
inline bool EQ(double vecc2, double b) { return fabs(vecc2-b) < 1e-9; }
const int mod=1000000007;
typedef long long ll;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n>>b)&1; }
inline void set_bit(int & n, int b) { n |= two(b); }
inline void unset_bit(int & n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) { int resultAns = 0; while(n && ++resultAns) n-=n&(-n); return resultAns; }
template<class T> void chmax(T & vecc2, const T & b) { vecc2 = max(vecc2, b); }
template<class T> void chmin(T & vecc2, const T & b) { vecc2 = min(vecc2, b); }
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
  cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
  const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
 
#define si(codx1) scanf("%i",&codx1)
#define sll(codx1) scanf("%lld",&codx1)
#define pi(codx1) printf("%i\n",codx1)
#define F first
#define S second
#define PB push_back
#define MP make_pair
 
typedef long long LL;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<PII> VPII;
 inline void add(int &codx1, int cody1){codx1+=cody1; if(codx1>=mod)codx1-=mod; if(codx1<0)codx1+=mod;}
inline int mul(int codx1, int cody1){ return ((LL)codx1 * cody1)%mod;}
int gcd(int vecc2, int b){ if(b)return gcd(b,vecc2%b); return vecc2;}
int power(int vecc2 ,int p){int ret = 1; while(p){if(p&1)ret=mul(ret,vecc2); vecc2=mul(vecc2,vecc2); p/=2;}return ret;}
#define lld long double
#define MOD 1000000007
using namespace std;


    const int INF=1000000000;
    const lld EPS=1e-9;
    int indx[25][25];
    char used[25][25];
    char grid[25][25];
    int mazes[25][25];
    
    int N=0;
    int n,m;

    lld vecc2[407][407];
    lld crrr[407];
    int geti(int codx1, int cody1)
    {
        if(indx[codx1][cody1]==-1)
        {
            indx[codx1][cody1]=N;
            N++;
        }
        return indx[codx1][cody1];
    }
    int gTy(int codx1, int cody1) 
    {
        if (codx1<0 || codx1>=n || cody1<0 || cody1>=m) return 1;
        if (grid[codx1][cody1]=='O' || grid[codx1][cody1]=='A') return 0;
        if (grid[codx1][cody1]=='#') 
            return 1;
        if (grid[codx1][cody1]=='%')
            return 2;
        if (grid[codx1][cody1]=='*')
            return 3;
        return 100;
    }

    

    void depth(int codx1, int cody1)
    {
        int xnum1=codx1;
        int ynum1=cody1;
        if(codx1<0 || codx1>=n || cody1<0 || cody1>=m || used[codx1][cody1]==1 || gTy(codx1,cody1)!=0)
            return;
        used[codx1][cody1]=1;

        int jj1 = geti(codx1,cody1);

        int h=0,r=0;
        

        if(mazes[codx1][cody1]!=-1)
        {
            xnum1 = mazes[codx1][cody1]/100;
            ynum1 = mazes[codx1][cody1]%100;
        }

        if(gTy(xnum1-1,ynum1)!=1)h++;
        if(gTy(xnum1,ynum1-1)!=1)h++;
        if(gTy(xnum1+1,ynum1)!=1)h++;
        if(gTy(xnum1,ynum1+1)!=1)h++;

        if(gTy(xnum1-1,ynum1)==2)r++;
        if(gTy(xnum1,ynum1-1)==2)r++;
        if(gTy(xnum1+1,ynum1)==2)r++;
        if(gTy(xnum1,ynum1+1)==2)r++;

        if(h==0)
        {
            vecc2[jj1][jj1]=1;
            return;
        }

        if(gTy(xnum1-1,ynum1)==0) vecc2[jj1][geti(xnum1-1,ynum1)]=-1;
        if(gTy(xnum1,ynum1-1)==0) vecc2[jj1][geti(xnum1,ynum1-1)]=-1;
        if(gTy(xnum1+1,ynum1)==0) vecc2[jj1][geti(xnum1+1,ynum1)]=-1;
        if(gTy(xnum1,ynum1+1)==0) vecc2[jj1][geti(xnum1,ynum1+1)]=-1;

        vecc2[jj1][jj1]+=h;
        crrr[jj1]=r;

        depth(xnum1-1,ynum1);
        depth(xnum1,ynum1-1);
        depth(xnum1+1,ynum1);
        depth(xnum1,ynum1+1);
    }


    int phyGa (vector < vector<lld> > vecc2, vector<lld> & vecc) {
        int n = (int) vecc2.size();
        int m = (int) vecc2[0].size() - 1;

        vector<int> ggc (m, -1);
        for (int tt2=0, row=0; tt2<m && row<n; ++tt2) {
            int tt1 = row;
            for (int i=row; i<n; ++i)
                if (abs (vecc2[i][tt2]) > abs (vecc2[tt1][tt2]))
                    tt1 = i;
            if (abs (vecc2[tt1][tt2]) < EPS)
                continue;
            for (int i=tt2; i<=m; ++i)
                swap (vecc2[tt1][i], vecc2[row][i]);
            ggc[tt2] = row;

            for (int i=0; i<n; ++i)
                if (i != row) {
                    lld crrr = vecc2[i][tt2] / vecc2[row][tt2];
                    for (int j=tt2; j<=m; ++j)
                        vecc2[i][j] -= vecc2[row][j] * crrr;
                }
            ++row;
        }

        vecc.assign (m, 0);
        for (int i=0; i<m; ++i)
            if (ggc[i] != -1)
                vecc[i] = vecc2[ggc[i]][m] / vecc2[ggc[i]][i];
        for (int i=0; i<n; ++i) {
            lld sum = 0;
            for (int j=0; j<m; ++j)
                sum += vecc[j] * vecc2[i][j];
            if (abs (sum - vecc2[i][m]) > EPS)
                return 0;
        }

        for (int i=0; i<m; ++i)
            if (ggc[i] == -1)
                return INF;
        return 1;
    }


    int main()
    {
        int k,i,j;
        int x1,x2,y1,y2,xa,ya;

        cin >>n >> m >> k;

        for(i=0;i<n;i++)
            cin >> grid[i];

        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
            {
                indx[i][j]=-1;
                mazes[i][j]=-1;
                used[i][j]=0;

                if(grid[i][j]=='A')
                {
                    xa=i;
                    ya=j;
                }
            }


        for(i=0;i<k;i++)
        {
            scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
            x1--;x2--;y1--;y2--;

            mazes[x1][y1]=100*x2+(y2);
            mazes[x2][y2]=100*x1+(y1);
        }


        for(i=0;i<400;i++)
        {
            for(j=0;j<400;j++)vecc2[i][j]=0;
            crrr[i]=0;
        }

        depth(xa,ya);

        char outs=1;
        for(int i=0;i<N;i++){
            if(crrr[i]!=0)
                outs=0;
        }
        if(outs)
        {
            cout << 0 << endl;
            return 0;
        }
        vector<lld> vecc;
        vector<vector<lld> > aa;
        aa.resize(N);
        for(int i=0;i<N;i++)
        {
            aa[i].resize(N+1);
            for(j=0;j<N;j++)aa[i][j]=vecc2[i][j];
            aa[i][N]=crrr[i];
        }

        

        int jj1 = phyGa(aa,vecc);

        cout<< fixed<<setprecision(10);
        cout<< vecc[geti(xa,ya)]<< endl;

        return 0;
    }