#include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstring>

 #include <vector>

 #include <queue>

 using namespace std;

 #define N 5000

 #define INF 2147483000

 struct Edge

 {

     int from,to,cap,flow;

     Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}

 };

 struct Dinic

 {

     int n,m,s,t;//结点数，边数（包括反向弧），源点编号，汇点编号

     vector<Edge>edges;//边表，dges[e]和dges[e^1]互为反向弧

     vector<int>G[N];//邻接表，G[i][j]表示结点i的第j条边在e数组中的编号

     bool vis[N]; //BFS的使用

     int d[N]; //从起点到i的距离

     int cur[N]; //当前弧下标

     void addedge(int from,int to,int cap)

     {

         edges.push_back(Edge(from,to,cap,));

         edges.push_back(Edge(to,from,,));

         int  m=edges.size();

         G[from].push_back(m-);

         G[to].push_back(m-);

     }

     bool bfs()

     {

         memset(vis,,sizeof(vis));

         queue<int>Q;

         Q.push(s);

         d[s]=;

         vis[s]=;

         while(!Q.empty())

         {

             int x=Q.front();Q.pop();

             for(int i=;i<G[x].size();i++)

             {

                 Edge&e=edges[G[x][i]];

                 if(!vis[e.to]&&e.cap>e.flow)//只考虑残量网络中的弧

                 {

                     vis[e.to]=;

                     d[e.to]=d[x]+;

                     Q.push(e.to);

                 }

             }

         }

         return vis[t];

     }

     int dfs(int x,int a)//x表示当前结点，a表示目前为止的最小残量

     {

         if(x==t||a==)return a;//a等于0时及时退出，此时相当于断路了

         int flow=,f;

         for(int&i=cur[x];i<G[x].size();i++)//从上次考虑的弧开始，注意要使用引用，同时修改cur[x]

         {

             Edge&e=edges[G[x][i]];//e是一条边

             if(d[x]+==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>)

             {

                 e.flow+=f;

                 edges[G[x][i]^].flow-=f;

                 flow+=f;

                 a-=f;

                 if(!a)break;//a等于0及时退出，当a!=0,说明当前节点还存在另一个曾广路分支。

             }

         }

         return flow;

     }

     int Maxflow(int s,int t)//主过程

     {

         this->s=s,this->t=t;

         int flow=;

         while(bfs())//不停地用bfs构造分层网络，然后用dfs沿着阻塞流增广

         {

             memset(cur,,sizeof(cur));

             flow+=dfs(s,INF);

         }

         return flow;

     }

 }dinic;

 int h,w,a,b;

 char G[][];

 const int dx[]={,,,-};

 const int dy[]={,-,,};

 int main(){

     scanf("%d%d%d%d",&h,&w,&a,&b);

     dinic.s=,dinic.t=h*w+;

     for(int i=;i<=h;i++){

         for(int j=;j<=w;j++){

             scanf(" %c",&G[i][j]);

             if(G[i][j]=='.')

                 dinic.addedge(dinic.s,(i-)*w+j,b);

             else

                 dinic.addedge((i-)*w+j,dinic.t,b);

         }

     }

     for(int i=;i<=h;i++){

         for(int j=;j<=w;j++){

             int u=(i-)*w+j;

             int v1=i*w+j;

             int v2=(i-)*w+j+;

             if(i<h){

                dinic.addedge(u,v1,a);dinic.addedge(v1,u,a);

             }

             if(j<w){

                dinic.addedge(u,v2,a);dinic.addedge(v2,u,a);

             }

         }

     }

     int ans=dinic.Maxflow(dinic.s,dinic.t);

     cout<<ans;

 return ;

 }