#include <array>
#include <cmath>
#include <cstdio>
#include <random>
#include <stack>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

struct Cell
{
    Cell(void) : blocked{false}, mine{false},tunnel{false}, visited{false}, tr{0}, tc{0} {}
    bool blocked;
    bool mine;
    bool tunnel;
    bool visited;
    size_t tr, tc; // tunnel exit
};

int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    size_t R, C, T;
    std::cin >> R >> C >> T;
    std::vector<std::vector<Cell>> maze(R, std::vector<Cell>(C, Cell{}));
    size_t fsr, fsc;
    size_t er, ec;
    for(size_t r{0}; r<R; ++r)
    {
        std::string s;
        std::cin >> s;
        for(size_t c{0}; c<C; ++c)
        {
            switch(s[c])
            {
                case '#':
                    maze[r][c].blocked=true;
                    break;
                case 'A':
                    fsr=r;
                    fsc=c;
                    break;
                case '*':
                    maze[r][c].mine=true;
                    break;
                case '%':
                    er=r;
                    ec=c;
                    break;
                case '0':
                default:
                    break;
            }
        }
    }
    for(size_t t{0}; t<T; ++t)
    {
        size_t r1, c1, r2, c2;
        std::cin >> r1 >> c1 >> r2 >> c2;
        --r1;
        --c1;
        --r2;
        --c2;
        maze[r1][c1].tunnel=true;
        maze[r1][c1].tr=r2;
        maze[r1][c1].tc=c2;
        maze[r2][c2].tunnel=true;
        maze[r2][c2].tr=r1;
        maze[r2][c2].tc=c1;
    }
    
    std::default_random_engine generator;
    std::uniform_int_distribution<size_t> roll2{0, 1};
    std::uniform_int_distribution<size_t> roll3{0, 2};
    std::uniform_int_distribution<size_t> roll4{0, 3};

    size_t wins{0}, losses;
    struct State
    {
        State(size_t row, size_t col, bool t) : r{row}, c{col}, tunnel{t} {}
        size_t r,c;
        bool tunnel;
    };
    std::stack<State> dfs;
    dfs.push(State{fsr, fsc, false});
    while(!dfs.empty())
    {
        State state{dfs.top()};
        dfs.pop();
        size_t fr=state.r;
        size_t fc=state.c;
        bool tunnel=state.tunnel;
        maze[fr][fc].visited=true;
        
        //std::cout << fr << ' ' << fc << std::endl;
        if (fr==er && fc==ec)
        {
            ++wins;
        }
        else if (maze[fr][fc].mine)
        {
            ++losses;
        }
        else if (maze[fr][fc].tunnel && !tunnel)
        {
            dfs.push(State{maze[fr][fc].tr, maze[fr][fc].tc, true});
        }
        else
        {
            // get number of free directions
            std::vector<std::pair<size_t, size_t>> freeCells;
            if (fr>0 && !maze[fr-1][fc].blocked)
            {
                freeCells.emplace_back(fr-1, fc);
            }
            if (fr<R-1 && !maze[fr+1][fc].blocked)
            {
                freeCells.emplace_back(fr+1, fc);
            }
            if (fc>0 && !maze[fr][fc-1].blocked)
            {
                freeCells.emplace_back(fr, fc-1);
            }
            if (fc<C-1 && !maze[fr][fc+1].blocked)
            {
                freeCells.emplace_back(fr, fc+1);
            }
            //std::cout << "Free " << freeCells.size() << std::endl;
            if (freeCells.empty())
            {
                ++losses;
            }
            else
            {
                for(std::pair<size_t, size_t>& freeCell : freeCells)
                {
                    if (!maze[freeCell.first][freeCell.second].visited)
                        dfs.push(State{freeCell.first, freeCell.second, false}); 
                }
            }    
        }
    }
    std::cout << static_cast<double>(wins)/(wins+losses) << std::endl;
    
    /*
    for(size_t trial{0}; trial<Trials; ++trial)
    {
        bool win{false};
        bool tunnel{false};
        size_t fr{fsr}, fc{fsc};
        size_t moves{0};
        while(moves<100)
        {
            //std::cout << fr << ' ' << fc << std::endl;
            if (fr==er && fc==ec)
            {
                win=true;
                break;
            }
            else if (maze[fr][fc].mine)
            {
                break;
            }
            else if (maze[fr][fc].tunnel && !tunnel)
            {

                fr=maze[fr][fc].tr;
                fc=maze[fr][fc].tc;
                tunnel=true;
            }
            else
            {
                // get number of free directions
                std::vector<std::pair<size_t, size_t>> freeCells;
                if (fr>0 && !maze[fr-1][fc].blocked)
                {
                    freeCells.emplace_back(fr-1, fc);
                }
                if (fr<R-1 && !maze[fr+1][fc].blocked)
                {
                    freeCells.emplace_back(fr+1, fc);
                }
                if (fc>0 && !maze[fr][fc-1].blocked)
                {
                    freeCells.emplace_back(fr, fc-1);
                }
                if (fc<C-1 && !maze[fr][fc+1].blocked)
                {
                    freeCells.emplace_back(fr, fc+1);
                }
                //std::cout << "Free " << freeCells.size() << std::endl;
                if (freeCells.empty()) break;
                
                // move random direction
                size_t roll{0};
                switch(freeCells.size())
                {
                    case 2:
                        roll=roll2(generator);
                        break;
                    case 3:
                        roll=roll3(generator);
                        break;
                    case 4:
                        roll=roll4(generator);
                        break;
                }
                fr=freeCells[roll].first;
                fc=freeCells[roll].second;
                tunnel=false;
            }
            ++moves;
        }
        //std::cout << "Trial: " << trial << ' ' << win << std::endl;
        if (win) ++wins;
    }
    
    std::cout << wins/static_cast<double>(Trials) << std::endl;
    */
    
    return 0;
}