#include <bits/stdc++.h>
using namespace std;
#define int long long
const int P = 80001;
const int E = 2000001;
struct FlowGraph {
    int s, t, vtot, etot, head[P], dis[P], cur[P];
    struct edge {
        int v, nxt;
        int f;
    } e[E * 2];
    void addedge(int u, int v, int f) {
        e[etot] = {v, head[u], f}; head[u] = etot ++;
        e[etot] = {u, head[v], 0}; head[v] = etot ++;
    }
    bool bfs() {
        for (int i = 1; i <= vtot; i ++) {
            dis[i] = 0;
            cur[i] = head[i];
        }
        std::queue<int> q;
        q.push(s);
        dis[s] = 1;
        while (! q.empty()) {
            int u = q.front();
            q.pop();
            for (int i = head[u]; ~i; i = e[i].nxt) {
                if (e[i].f && ! dis[e[i].v]) {
                    int v = e[i].v;
                    dis[v] = dis[u] + 1;
                    if (v == t) return true;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int dfs(int u, int m) {
        if (u == t) return m;
        int flow = 0;
        for (int i = cur[u]; ~i; cur[u] = i = e[i].nxt) {
            if (e[i].f && dis[e[i].v] == dis[u] + 1) {
                int f = dfs(e[i].v, std::min(m, e[i].f));
                e[i].f -= f;
                e[i ^ 1].f += f;
                m -= f;
                flow += f;
                if (! m) break;
            }
        }
        if (! flow) dis[u] = -1;
        return flow;
    }

    int dicnic() {
        int flow = 0;
        while (bfs()) {
            flow += dfs(s, std::numeric_limits<int>::max());
        }
        return flow;
    }
    void init(int _s, int _t, int _vtot) {
        s = _s;
        t = _t;
        vtot = _vtot;
        etot = 0;
        for (int i = 1; i <= vtot; i ++) {
            head[i] = -1;
        }
    }
};
signed main()
{
    int n, m, c, d;
    std::cin >> n >> m >> c >> d;
    std::vector<std::vector<char> > a(n + 1, std::vector<char>(m + 1));
    int num = 0;
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= m; j ++) {
            std::cin >> a[i][j];
            if (a[i][j] == '.') {
                num ++;
            }
        }
    }
	FlowGraph g;
    int s = n + m + 1, t = s + 1;
    g.init(s, t, t);
   	long long ans = 1ll * num * d;
	int op = std::max(n, m);
    int now = 0, i = 1;
	for (int j = 1; j <= n; j ++) {
		for (int k = 1; k <= m; k ++) {
			if (a[j][k] == '.') {
				g.addedge(j, n + k, 1);
			}
		}
	}
    while (i <= op) {
    	for (int j = 1; j <= n; j ++) {
    		g.addedge(s, j, 1);
		}
		for (int j = 1; j <= m; j ++) {
			g.addedge(n + j, t, 1);
		}
		int res = g.dicnic();
//		if (! res) {
//			break;
//		}
		now += res;
		ans = std::min(ans, 1ll * (num - now) * d + 1ll * i * c);
		i ++;
	}
    std::cout << ans << '\n';
    return 0;
}
/*
13 20 823772868 410753944
.....*......**......
.......*............
...............*....
......*.............
...................*
*........*.*..*.....
.....*.............*
..*..........*.*....
.......*............
...**...........**.*
....................
**......**.......*..
.*.............*....
*/