#include <bits/stdc++.h>

template <class Flow>
class mf_network {
public:
  typedef std::size_t size_type;

  static const Flow INF_flow = std::numeric_limits<Flow>::max();

protected:
  struct edge {
    size_type u, v;
    Flow flow;

    edge(size_type t_u, size_type t_v, Flow t_flow)
    : u(t_u), v(t_v), flow(t_flow) {}
  };

  static const size_type npos = static_cast<size_type>(-1);

  size_type n, S, T;
  std::vector<edge> edges;
  std::vector<std::vector<size_type>> E;

  std::vector<size_type> dep;

  bool bfs() {
    std::fill(dep.begin(), dep.end(), npos);
    std::vector<size_type> Q;
    dep[S] = 0;
    Q.push_back(S);
    if (S == T) {
      return true;
    }
    for (size_type i = 0; i < Q.size(); ++i) {
      size_type u = Q[i];
      for (size_type id : E[u]) {
        size_type v = edges[id].v;
        Flow flow = edges[id].flow;
        if (flow && dep[v] == npos) {
          dep[v] = dep[u] + 1;
          Q.push_back(v);
          if (v == T) {
            return true;
          }
        }
      }
    }
    return false;
  }

  std::vector<size_type> iter;

  Flow dfs(size_type u, Flow all) {
    if (u == T || !all) {
      return all;
    }
    Flow res = 0;
    for (size_type &i = iter[u]; i < E[u].size(); ++i) {
      size_type id = E[u][i];
      size_type v = edges[id].v;
      Flow flow = edges[id].flow;
      if (dep[v] == dep[u] + 1) {
        Flow tmp = dfs(v, std::min(all, flow));
        if (tmp) {
          edges[id].flow -= tmp, edges[id ^ 1].flow += tmp;
          res += tmp, all -= tmp;
          if (!all) {
            break;
          }
        }
      }
    }
    if (!res) {
      dep[u] = npos;
    }
    return res;
  }

public:
  mf_network(size_type t_n) : n(t_n), E(n), dep(n), iter(n) {}

  void add_edge(size_type u, size_type v, Flow c) {
    E[u].push_back(edges.size()), edges.emplace_back(u, v, c);
    E[v].push_back(edges.size()), edges.emplace_back(v, u, 0);
  }

  size_type edge_size() {
    return edges.size() >> 1;
  }

  void slope(size_type t_S, size_type t_T, Flow &flow) {
    S = t_S, T = t_T;
    flow = 0;
    while (bfs()) {
      std::fill(iter.begin(), iter.end(), 0);
      flow += dfs(S, INF_flow);
    }
  }

  Flow edge_flow(size_type id) {
    return edges[id << 1 | 1].flow;
  }
};

int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int n, m, a, b, c;
  std::cin >> n >> m >> a >> b >> c;
  mf_network<int> G(n * m * 4 + 2);
  std::vector<std::vector<int>> bh(n, std::vector<int>(m));
  std::vector<std::vector<int>> bv(n, std::vector<int>(m));
  std::vector<std::vector<int>> wh(n, std::vector<int>(m));
  std::vector<std::vector<int>> wv(n, std::vector<int>(m));
  int idx = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      bh[i][j] = idx++;
      bv[i][j] = idx++;
      wh[i][j] = idx++;
      wv[i][j] = idx++;
    }
  }
  int S = idx++, T = idx++;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      G.add_edge(bh[i][j], T, a);
      G.add_edge(S, bv[i][j], a);
      G.add_edge(S, wh[i][j], a);
      G.add_edge(wv[i][j], T, a);
      if (j + 1 < m) {
        G.add_edge(bh[i][j], bh[i][j + 1], b);
        G.add_edge(wh[i][j + 1], wh[i][j], b);
      } else {
        G.add_edge(bh[i][j], T, b);
        G.add_edge(S, wh[i][j], b);
      }
      if (i + 1 < n) {
        G.add_edge(bv[i + 1][j], bv[i][j], b);
        G.add_edge(wv[i][j], wv[i + 1][j], b);
      } else {
        G.add_edge(S, bv[i][j], b);
        G.add_edge(wv[i][j], T, b);
      }
    }
  }
  for (int i = 0; i < n; ++i) {
    std::string s;
    std::cin >> s;
    for (int j = 0; j < m; ++j) {
      if (s[j] == '#') {
        G.add_edge(bv[i][j], bh[i][j], c);
        G.add_edge(S, wh[i][j], G.INF_flow);
        G.add_edge(wv[i][j], T, G.INF_flow);
      } else {
        G.add_edge(bh[i][j], wv[i][j], c);
        G.add_edge(wh[i][j], bv[i][j], c);
        G.add_edge(bh[i][j], bv[i][j], G.INF_flow);
      }
    }
  }
  int flow;
  G.slope(S, T, flow);
  std::cout << flow << "\n";
}