#include <bits/stdc++.h>

using namespace std;
using i64 = long long;

template <class T>
struct MaxFlow {
  static constexpr T inf = numeric_limits<T>::max() / 2;
  struct Edge {
    int v;
    T c;
    Edge(int v, T c) : v{v}, c{c} {}
  };
  int n;
  vector<Edge> e;
  vector<vector<int>> g;
  vector<int> h, cur;
  MaxFlow() {}
  MaxFlow(int n) { init(n); }
  void init(int n) {
    this->n = n;
    e.clear();
    g.assign(n, {});
    h.resize(n);
    cur.resize(n);
  }
  void addEdge(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);
  }
  bool bfs(int s, int t) {
    h.assign(n, -1);
    queue<int> que;
    h[s] = 0;
    que.push(s);
    while (!que.empty()) {
      int x = que.front();
      que.pop();
      for (int i : g[x]) {
        auto [y, c] = e[i];
        if (c > 0 && h[y] == -1) {
          h[y] = h[x] + 1;
          if (y == t) {
            return true;
          }
          que.push(y);
        }
      }
    }
    return false;
  }
  T dfs(int x, int t, T f) {
    if (x == t) {
      return f;
    }
    T r = f;
    for (int &i = cur[x]; i < g[x].size(); i++) {
      int j = g[x][i];
      auto [y, c] = e[j];
      if (c > 0 && h[y] == h[x] + 1) {
        T u = dfs(y, t, min(r, c));
        e[j].c -= u;
        e[j ^ 1].c += u;
        r -= u;
        if (r == 0) {
          return f;
        }
      }
    }
    return f - r;
  }
  T flow(int s, int t) {
    T flow{};
    while (bfs(s, t)) {
      cur.assign(n, 0);
      flow += dfs(s, t, inf);
    }
    return flow;
  }
};

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

  vector<vector<int>> a(n, vector<int>(m, 0));
  for (int i = 0; i < n; i++) {
    string s;
    cin >> s;
    for (int j = 0; j < m; j++) {
      a[i][j] = s[j] == '.';
    }
  }

  int S = n + m, T = S + 1;
  MaxFlow<int> mf(T + 1);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      if (a[i][j] == 1) {
        mf.addEdge(i, n + j, 1);
      }
    }
  }

  int z = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      z += a[i][j];
    }
  }
  i64 ans = numeric_limits<i64>::max();
  for (int k = 0; k <= max(n, m); k++) {
    ans = min(ans, 1LL * c * k + 1LL * d * z);
    for (int i = 0; i < n; i++) {
      mf.addEdge(S, i, 1);
    }
    for (int j = 0; j < m; j++) {
      mf.addEdge(n + j, T, 1);
    }
    z -= mf.flow(S, T);
  }
  cout << ans << "\n";
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout << fixed << setprecision(16);

  int t = 1;

  while (t--) {
    solve();
  }

  return 0;
}