/*
 * _|_|_|_|_|  _|_|_|_|    _|_|_|  _|_|_|_|_|  _|_|_|      _|_|   
 *       _|    _|        _|                _|        _|  _|    _| 
 *     _|      _|_|_|      _|_|          _|      _|_|        _|   
 *   _|        _|              _|      _|            _|    _|     
 * _|_|_|_|_|  _|        _|_|_|      _|        _|_|_|    _|_|_|_| 
 */

#include <bits/stdc++.h>

constexpr int maxN = 40;
constexpr int maxV = maxN * maxN * 4 + 2;
constexpr int maxE = 1E5;
constexpr int INF = 1E7;

namespace Dinic {
  struct Edge {
    int nxt, to, flow;
  } edge[maxE << 1];

  int n, s, t, cnt, dep[maxV];
  int fir[maxV], cur[maxV];

  void Init(int _n = 0) {
    n = _n, cnt = 0;
    memset(fir, -1, sizeof(int) * (n + 1));
  }

  void AddEdge(int u, int v, int cap) {
    edge[cnt] = {fir[u], v, cap};
    fir[u] = cnt++;
    edge[cnt] = {fir[v], u, 0};
    fir[v] = cnt++;
  }

  bool BFS() {
    for (int i = 0; i <= n; i++) dep[i] = 0, cur[i] = fir[i];
    std::queue<int> q;
    dep[s] = 1, q.emplace(s);
    while (!q.empty()) {
      int u = q.front();
      q.pop();
      for (int e = fir[u]; ~e;) {
        auto [nxt, v, f] = edge[e];
        if (!dep[v] && f) dep[v] = dep[u] + 1, q.emplace(v);
        e = nxt;
      }
    }
    return dep[t];
  }

  int DFS(int u, int val) {
    if (u == t || !val) return val;
    int res = 0;
    for (int &e = cur[u]; ~e;) {
      int d;
      auto &[nxt, v, f] = edge[e];
      if (dep[v] == dep[u] + 1 && (d = DFS(v, std::min(val - res, f))))
        res += d, f -= d, edge[e ^ 1].flow += d;
      if (res == val) return res;
      e = nxt;
    }
    return res;
  }

  int MaxFlow(int _s, int _t, bool clear = false) {
    s = _s, t = _t;
    if (clear) {
      for (int i = 0; i < cnt; i += 2) {
        edge[i].flow += edge[i ^ 1].flow;
        edge[i ^ 1].flow = 0;
      }
    }
    int maxFlow = 0;
    while (BFS()) maxFlow += DFS(s, INT_MAX);
    return maxFlow;
  }
}// namespace Dinic

int main() {
#ifdef LOCAL
  freopen("task.in", "r", stdin);
  freopen("task.out", "w", stdout);
  freopen("task.err", "w", stderr);
#endif
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int N, M, A, B, C;
  std::cin >> N >> M >> A >> B >> C;

  int S = N * M * 4, T = S + 1;
  Dinic::Init(T);

  auto Get = [&](int x, int y, int c) { return (x * M + y) * 4 + c; };
  auto HB = [&](int x, int y) { return Get(x, y, 0); };
  auto VW = [&](int x, int y) { return Get(x, y, 1); };
  auto HW = [&](int x, int y) { return Get(x, y, 2); };
  auto VB = [&](int x, int y) { return Get(x, y, 3); };
  auto Assert = [&](int c, int x) { Dinic::AddEdge(S, x, c); };
  auto Not = [&](int c, int x) { Dinic::AddEdge(x, T, c); };
  auto Bound = [&](int c, int x, int y) { Dinic::AddEdge(y, x, c); };

  for (int i = 0; i < N; i++) {
    for (int j = 0; j < M; j++) {
      char c;
      std::cin >> c;
      if (c == '#') {
        Bound(C, VB(i, j), HB(i, j));
        Assert(INF, VW(i, j));
        Not(INF, HW(i, j));
      } else {
        Bound(INF, HB(i, j), VB(i, j));
        Bound(C, HB(i, j), VW(i, j));
        Bound(C, HW(i, j), VB(i, j));
      }
      Bound(INF, HB(i, j), HW(i, j));
      Bound(INF, VW(i, j), VB(i, j));
      Assert(A, HB(i, j));
      Assert(A, VW(i, j));
      Not(A, HW(i, j));
      Not(A, VB(i, j));
      if (i + 1 == N) {
        Assert(B, HB(i, j));
        Not(B, HW(i, j));
      } else {
        Bound(B, HB(i, j), HB(i + 1, j));
        Bound(B, HW(i + 1, j), HW(i, j));
      }
      if (j + 1 == M) {
        Assert(B, VW(i, j));
        Not(B, VB(i, j));
      } else {
        Bound(B, VW(i, j), VW(i, j + 1));
        Bound(B, VB(i, j + 1), VB(i, j));
      }
    }
  }

  std::cout << Dinic::MaxFlow(S, T) << '\n';

  return 0;
}