#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using i64 = long long;
using pii = pair<int, int>;
using db = double;
#define int ll

#define cY cout << "YES\n"
#define cN cout << "NO\n"
#define cA cout << ans << "\n"
#define pb push_back

const int N = 2e5 + 7;
const ll mod = 998244353;
const ll MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;

template <class T>
struct Flow {
    const int n;

    std::vector<std::pair<int, T>> e;
    std::vector<std::vector<int>> g;
    std::vector<int> cur, dep;

    Flow(int n) : n(n), g(n) {}

    bool bfs(int s, int t) {
        dep.assign(n, -1);
        std::queue<int> q;
        dep[s] = 0;

        q.push(s);
        while (!q.empty()) {
            const int u = q.front();
            q.pop();

            for (int i : g[u]) {
                auto [v, c] = e[i];

                if (c > 0 and dep[v] == -1) {
                    dep[v] = dep[u] + 1;
                    if (v == t)
                        return true;
                    q.push(v);
                }
            }
        }

        return false;
    }

    T dfs(int u, int t, T f) {
        if (u == t) {
            return f;
        }
        T res = f;
        for (int &i = cur[u]; i < g[u].size(); i++) {
            const int j = g[u][i];
            auto [v, c] = e[j];

            if (c > 0 and dep[v] == dep[u] + 1) {
                T out = dfs(v, t, std::min(res, c));
                e[j].second -= out;
                e[j ^ 1].second += out;

                res -= out;
                if (res == 0) {
                    return f;
                }
            }
        }
        return f - res;
    }

    void add(int u, int v, T c) {
        g[u].push_back(e.size());
        e.emplace_back(v, c);
        g[v].push_back(e.size());
        e.emplace_back(u, 0);
    }

    T work(int s, int t) {
        T ans = 0;
        while (bfs(s, t)) {
            cur.assign(n, 0);
            ans += dfs(s, t, std::numeric_limits<T>::max());
        }
        return ans;
    }
};

void crossparallel() {
    int n, m, c, d;
    cin >> n >> m >> c >> d;

    vector<string> mp(n);
    for (int i = 0; i < n; i++) cin >> mp[i];

    int ans = INF;
    for (int k = 0; k <= max(n, m); k++) {
        Flow<ll> flow(n + m + 3);
        int s = n + m + 1, t = n + m + 2;
        int cnt = 0;

        for (int i = 0; i < n; i++)
            flow.add(s, i, k);
        for (int i = 0; i < m; i++)
            flow.add(i + n, t, k);

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (mp[i][j] == '.') {
                    cnt++;
                    flow.add(i, j + n, 1);
                }
            }
        }

        auto z = cnt - flow.work(s, t);
        ans = min(ans, c * k + d * z);
    }

    cA;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    // cin >> t;
    while (t--) {
        crossparallel();
    }
    return 0;
}