#include <bits/stdc++.h>

using namespace std;

template<class Z>
struct MaxFlow {
  static constexpr Z inf = numeric_limits<Z>::max();

  int n;
  vector<vector<tuple<int, int, Z>>> g;

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

  int newNode() { g.emplace_back(); return n++; }

  void addEdge(int u, int v, Z c) {
    int ru = g[u].size(), rv = g[v].size();
    g[u].emplace_back(v, rv, c), g[v].emplace_back(u, ru, 0);
  }

  vector<int> level, cur;
  Z dinic(int s, int t) {
    level.resize(n), cur.resize(n);
    auto getLevel = [&]() {
      queue<int> q; fill_n(level.begin(), n, -1), q.push(s), level[s] = 0;
      while (!q.empty()) {
        int u = q.front(); q.pop();
        for (auto [v, _, c]: g[u])
          if (c && level[v] == -1) level[v] = level[u] + 1, q.push(v);
      }
    };
    function<Z(int, Z)> cap = [&](int u, Z lim) {
      if (u == t) return lim;
      Z ret = 0;
      for (; cur[u] && ret < lim; --cur[u]) {
        auto &[v, rev, c] = g[u][cur[u] - 1];
        if (level[v] == level[u] + 1) {
          Z flow = cap(v, min(lim - ret, c));
          ret += flow, c -= flow, get<2>(g[v][rev]) += flow;
          if (ret == lim) return ret;
        }
      }
      return ret;
    };
    Z ret = 0;
    while (getLevel(), level[t] != -1) {
      for (int i = 0; i < n; ++i) cur[i] = g[i].size();
      ret += cap(s, inf);
    }
    return ret;
  }
};

int main() {
  int n, m, a, b; cin >> n >> m >> a >> b;
  MaxFlow<int> maxFlow(n * m + 2); int s = n * m, t = s + 1;
  vector<string> str(n);
  for (int i = 0; i < n; ++i) cin >> str[i];
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) {
      if (str[i][j] == '.') maxFlow.addEdge(s, i * m + j, b);
      else maxFlow.addEdge(i * m + j, t, b);
      for (auto [dx, dy] : vector<pair<int, int>>{{0, 1}, {0, -1}, {1, 0}, {-1, 0}}) {
        int nx = i + dx, ny = j + dy;
        if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
        maxFlow.addEdge(i * m + j, nx * m + ny, a);
      }
    }
  printf("%d\n", maxFlow.dinic(s, t));
}