#include <bits/stdc++.h>

using namespace std;

#define ll long long
#define REP1(i, n) for(ll i = 0; i < (n); i++)
#define REP2(i, a, b) for(ll i = (a); i < (b); i++)
#define REP0(n) for(ll iii = 0; iii < (n); iii++)
#define overload3(a, b, c, name, ...) name
#define rep(...) overload3(__VA_ARGS__, REP2, REP1, REP0)(__VA_ARGS__)
#define si(c) (ll)(c.size())
#define pll pair<ll, ll>

#define vl vector<ll>
#define all(v) v.begin(), v.end()
#define fore(e, v) for(auto &&e : v)

template <typename T, typename S> bool chmax(T &x, const S &y) { return (x < y ? x = y, true : false); }
template <typename T, typename S> bool chmin(T &x, const S &y) { return (x > y ? x = y, true : false); }

template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "{";
    rep(i, si(v)) {
        if(i) os << ", ";
        os << v[i];
    }
    return os << "}";
}

struct Dinic {
    const ll INF;

    struct edge {
        int to;
        ll cap;
        int rev;
        bool isrev;
        int idx;
    };

    vector<vector<edge>> g;
    vector<int> min_cost, iter;

    Dinic(int V) : INF(1e18), g(V) {}

    void add_edge(int from, int to, ll cap, int idx = -1) {
        g[from].emplace_back((edge){to, cap, (int)si(g[to]), false, idx});
        g[to].emplace_back((edge){from, 0, (int)si(g[from]) - 1, true, idx});
    }

    bool bfs(int s, int t) {
        min_cost.assign(g.size(), -1);
        queue<int> que;
        min_cost[s] = 0;
        que.push(s);
        while(!que.empty() and min_cost[t] == -1) {
            int p = que.front();
            que.pop();
            fore(e, g[p]) {
                if(e.cap > 0 and min_cost[e.to] == -1) {
                    min_cost[e.to] = min_cost[p] + 1;
                    que.push(e.to);
                }
            }
        }
        return min_cost[t] != -1;
    }

    ll dfs(int idx, const int t, ll flow) {
        if(idx == t) return flow;
        for(int &i = iter[idx]; i < g[idx].size(); i++) {
            edge &e = g[idx][i];
            if(e.cap > 0 and min_cost[idx] < min_cost[e.to]) {
                ll d = dfs(e.to, t, min(flow, e.cap));
                if(d > 0) {
                    e.cap -= d;
                    g[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }

    ll max_flow(int s, int t) {
        ll flow = 0;
        while(bfs(s, t)) {
            iter.assign(g.size(), 0);
            ll f = 0;
            while((f = dfs(s, t, INF)) > 0) flow += f;
        }
        return flow;
    }
};

int main() {
    ll n, m, c, d;
    cin >> n >> m >> c >> d;

    Dinic flow(n + m + 2);
    int s = n + m, t = s + 1;

    ll cnt = 0;
    rep(i, n) rep(j, m) {
        char c;
        cin >> c;
        if(c == '.') {
            cnt++;
            flow.add_edge(i, n + j, 1);
        }
    }

    ll mi = cnt * d;

    ll f = 0;
    rep(i, 1, max(n, m) + 1) {
        rep(i, n) flow.add_edge(s, i, 1);
        rep(i, m) flow.add_edge(n + i, t, 1);
        f += flow.max_flow(s, t);
        chmin(mi, i * c + (cnt - f) * d);
    }

    cout << mi << endl;
}