#include<algorithm>
#include<array>
#include<bitset>
#include<cassert>
#include<cmath>
#include<complex>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<deque>
#include<functional>
#include<iostream>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<sstream>
#include<string>
#include<tuple>
#include<unordered_map>
#include<unordered_set>
#include<vector>
using namespace std;

#define db(x){if(cond){cerr<<__LINE__<<" "<<#x<<" " <<x<<endl;cerr.flush();}}
#define db2(x){if(cond){cerr<<x;cerr.flush();}}
#define rep(i,b)for(auto i=(0);i<(b);++i)
#define fo(i,a,b)for(auto i=(a);i<=(b);++i)
#define ford(i,a,b)for(auto i=(a);i>=(b);--i)
#define fore(a,b)for(auto &a:b)
#define vv vector
#define pb push_back
#define all(x)(x).begin(),(x).end()
#define clr(x,a)memset(x,a,sizeof(x))
#define MA(a,b){a=max(a,b);}
#define MI(a,b){a=min(a,b);}
typedef long long ll;typedef long double ld;typedef vv<int>vi;typedef vv<string>vs;
typedef pair<int,int>pi2;typedef array<int,2>i2;typedef array<int,3>i3;
typedef array<ld,2>ld2;typedef array<ll,2>ll2;
int cond=0,multi=0,gcj=0;

// #define DEBUG 1
#if DEBUG
#define cin io
stringstream io;
int init(){int N=5;io<<N<<endl; return 0;}
int xxx=init();
#endif


#define EPS 1e-9
ld IsZero(ld x){return abs(x)<=EPS;}

vector<ld> gauss(vector<vector<ld> > &A, vector<ld> B) {
  int N=A.size(); int M = A[0].size();
  vector<ld> used(N,0);

  rep (j, M) {
    int best_r=j;
    fo(i,j,N-1)if(abs(A[i][j])>abs(A[best_r][j]))best_r=i;

    fo(k,j,M-1)swap(A[j][k],A[best_r][k]);
    swap(B[j],B[best_r]);
    if(IsZero(A[j][j])){B.resize(0);return B;}
    B[j]/=A[j][j];
    ford(k,M-1,j)A[j][k]/=A[j][j];
    fo(r,0,N-1)if(r!=j){
      B[r]-=A[r][j]*B[j];
      ford(c,M-1,j)A[r][c]-=A[r][j]*A[j][c];
    }
  }
  B.resize(M);
  return B;
}


char A[33][33];
i2 TARGET[33][33];
vv<i2>NEI[33][33];
bool VIS[33][33];

i2 dir[]={{{1,0}},{{-1,0}},{{0,-1}},{{0,1}}};
i2 operator+(i2 le,i2 ri){return {{le[0]+ri[0],le[1]+ri[1]}};}

void go(int r,int c){
  if(VIS[r][c])return;
  if(A[r][c]=='O'||A[r][c]=='A'||A[r][c]=='*'||A[r][c]=='%'){
    VIS[r][c]=1;
    fore(d,dir){
      i2 npos=d+i2({{r,c}});
      go(npos[0],npos[1]);
    }
  }
}

struct solver{
  void solve(){
    int N,M,K;cin>>N>>M>>K;
    db(N<<" "<<M<<" "<<K);
    fo(r,1,N)fo(c,1,M)cin>>A[r][c];
    rep(k,K){
      int r1,c1,r2,c2;cin>>r1>>c1>>r2>>c2;
      db(r1<<" "<<c1<<" "<<r2<<" "<<c2);
      TARGET[r1][c1]={{r2,c2}};
      TARGET[r2][c2]={{r1,c1}};
    }
    vector<vector<ld>>a(N*M,vector<ld>(N*M));
    vv<ld>B(N*M);

    db("");
    fo(r,1,N)fo(c,1,M){
      vv<i2>&nei=NEI[r][c];
      fore(d,dir){
        i2 npos=d+i2({{r,c}});
        if(A[npos[0]][npos[1]]=='O'||
           A[npos[0]][npos[1]]=='A'||
           A[npos[0]][npos[1]]=='*'||
           A[npos[0]][npos[1]]=='%'){
          nei.pb(npos);
        }
      }
    }
    int start=0;

    fo(r,1,N)fo(c,1,M) if(A[r][c]=='A')start=(r-1)*M+c-1,go(r,c);
    fo(r,1,N)fo(c,1,M) if(A[r][c]=='%'&&VIS[r][c]==0){
      cout<<0<<endl;
      return;
    }
    db("");

    fo(r,1,N)fo(c,1,M){
      int cur=(r-1)*M+(c-1);
      a[cur][cur]=1;
      if(VIS[r][c]==0)continue;
      if(A[r][c]=='%')B[cur]=1;
      else if(A[r][c]=='A'||A[r][c]=='O'){
        db(r<<" "<<c<<" "<<A[r][c]);
        if(TARGET[r][c]!=i2()){
          db(r<<" "<<c);
          auto tar=TARGET[r][c];
          fore(nei,NEI[tar[0]][tar[1]]){
            db("");
            int next=(nei[0]-1)*M+nei[1]-1;
            a[cur][next]=-1.0/NEI[tar[0]][tar[1]].size();
          }
        }
        else {
          fore(nei,NEI[r][c]){
            db("");
            int next=(nei[0]-1)*M+nei[1]-1;
            a[cur][next]=-1.0/NEI[r][c].size();
          }
        }
      }
    }
    db("");
    vector<ld>C=gauss(a,B);
    assert(C.size());
    cout<<C[start]<<endl;
  }
};

int main(int argc,char** argv) {
  ios::sync_with_stdio(false);cond=argc>=2&&argv[1][0]=='q'?1<<30:0;
  cout.setf(ios::fixed); cout.precision(10); int t;if(multi||gcj) cin>>t; else t=1;
  fo(i,1,t) {if(cond)cerr<<__LINE__<<" "<<i<<endl; if(gcj)cout<<"Case #"<<i<<": ";
    solver s; s.solve();
  } return 0; }