#include <iostream>
#include <deque>
#include <vector>
#include <map>
#include <limits>

typedef std::vector<std::map<int, int> > graph;


bool bfs(const graph &g, int s, int t, std::vector<int> &parent)
{
    int V = g.size();
    std::vector<bool> visited(V);

    std::deque<int> q;
    q.push_back(s);
    visited[s] = true;
    parent[s] = -1;

    while (!q.empty()) {
        int u = q.front();
        q.pop_front();

        for (auto it : g[u])
        {
            int v = it.first;
            if (visited[v] == false && it.second > 0) {
                if (v == t) {
                    parent[v] = u;
                    return true;
                }
                q.push_back(v);
                parent[v] = u;
                visited[v] = true;
            }
        }
    }

    return false;
}

int fordFulkerson(const graph &g, int s, int t)
{
    graph rg = g;
    int V = g.size();
    std::vector<int> parent(V);

    int max_flow = 0;

    while (bfs(rg, s, t, parent)) {
        int path_flow = std::numeric_limits<int>::max();
        for (int v = t; v != s; v = parent[v]) {
            int u = parent[v];
            path_flow = std::min(path_flow, rg[u][v]);
        }

        for (int v = t; v != s; v = parent[v]) {
            int u = parent[v];
            rg[u][v] -= path_flow;
            rg[v][u] += path_flow;
        }

        max_flow += path_flow;
    }
    
    return max_flow;
}

int main()
{
    int h, w, t;
    std::cin >> h >> w >> t;
    std::vector<char> grid(h*w);
    for(int i=0; i<h*w; i++)
        std::cin >> grid[i];
    
    graph g(2*h*w*(t+1)+2);
    int people = 0;
    for(int i=0; i<h; i++)
    {
        for(int j=0; j<w; j++)
        {
            if(grid[i*w+j] == '#')
                continue;
            
            if(grid[i*w+j] == 'P')
            {
                g[0][2 + i*w + j] = 1;
                people++;
            }
                
            if(grid[i*w+j] == 'E')
            {
                for(int x=0; x<=t; x++)
                {
                    g[2 + 2*h*w*x + h*w + i*w + j][1] = 1;
                }
            }
            for(int x=0; x<=t; x++)
                g[2 + 2*h*w*x + i*w+j][2 + 2*h*w*x + h*w + i*w+j] = 1;
            for(int x=0; x<t; x++)
                g[2 + 2*h*w*x +h*w + i*w+j][2 + 2*h*w*(x+1) + i*w+j] = 1;
            int di[] = {-1,0,1,0};
            int dj[] = {0,1,0,-1};
            for(int k=0; k<4; k++)
            {
                int nbi = i + di[k];
                int nbj = j + dj[k];
                if(nbi >= 0 && nbi < h && nbj >= 0 && nbj < w)
                {
                    if(grid[nbi*w+nbj] != '#')
                    {
                        for(int x=0; x<t; x++)
                        {
                            g[2+ 2*h*w*x + h*w + i*w+j][2 + 2*h*w*(x+1) + nbi*w+nbj] = 1;
                        }
                    }
                }
            }
        }
    }
    
    std::cout << fordFulkerson(g, 0, 1);
}