#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ld = long double;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using vvi = std::vector<vi>;
using vii = std::vector<pii>;
using vll = std::vector<ll>;
using pll = std::pair<ll, ll>;
template <typename T>
int sign(const T& t) {
  return (t > 0) - (t < 0);
}
template <typename T, typename U>
bool remax(T& a, U b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T, typename U>
bool remin(T& a, U b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
T gcd(T a, T b) {
  a = std::abs(a);
  b = std::abs(b);
  while (b) {
    a %= b;
    std::swap(a, b);
  }
  return a;
}
template <typename T>
T lcm(T a, T b) {
  a = std::abs(a);
  b = std::abs(b);
  return a / gcd(a, b) * b;
}
double get_time() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
uint32_t mrand_32t() {
  static std::random_device rd;
  static std::mt19937 rng(rd());
  return rng();
}
uint64_t mrand_64t() {
  static std::random_device rd;
  static std::mt19937_64 rng(rd());
  return rng();
}
template <typename T>
void make_unique(std::vector<T>& v) {
  std::sort(std::begin(v), std::end(v));
  v.erase(std::unique(std::begin(v), std::end(v)), std::end(v));
}
namespace std {
template <typename A, typename B>
string to_string(const pair<A, B>& p) {
  string str;
  str += "(";
  str += to_string(p.first);
  str += ", ";
  str += to_string(p.second);
  str += ")";
  return str;
}
string to_string(bool value) { return value ? "true" : "false"; }
template <typename T>
string to_string(const vector<T>& vec) {
  string str = "{ ";
  bool first = true;
  for (const auto& it : vec) {
    if (!first) {
      str += ", ";
    }
    str += to_string(it);
    first = false;
  }
  str += " }";
  return str;
}
template <typename T>
string to_string(const set<T>& s) {
  string str = "{ ";
  bool first = true;
  for (const auto& it : s) {
    if (!first) {
      str += ", ";
    }
    str += to_string(it);
    first = false;
  }
  str += " }";
  return str;
}
template <typename K, typename V>
string to_string(const map<K, V>& m) {
  string str = "{ ";
  bool first = true;
  for (const auto& it : m) {
    if (!first) {
      str += ", ";
    }
    first = false;
    str += to_string(it.first);
    str += " -> ";
    str += to_string(it.second);
  }
  str += " }";
  return str;
}
string to_string(const string& s) { return "\"" + s + "\""; }
string to_string(const char* s) { return to_string(string(s)); }
string to_string(char ch) { return "\'" + string(1, ch) + "\'"; }
template <size_t N>
string to_string(const bitset<N>& b) {
  string res(N, '0');
  for (size_t i = 0; i < N; ++i) {
    res[i] = '0' + b[i];
  }
  return res;
}
template <typename T>
string to_string(const T& t) {
  std::stringstream ss;
  ss << t;
  return ss.str();
}
}  // namespace std
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  std::cerr << " " << std::to_string(H);
  debug_out(T...);
}
using namespace std;
struct pnt {
  int x, y;
  pnt trans() const { return pnt{x + y, x - y}; }
};
int n;
vector<pnt> ps;
bool read() {
  int h, w;
  if (!(cin >> h >> w)) {
    return 0;
  }
  ps.clear();
  for (int i = int(0); i < int(h); ++i) {
    string s;
    cin >> s;
    assert(int((s).size()) == w);
    for (int j = int(0); j < int(w); ++j) {
      if (s[j] == '#') {
        ps.push_back(pnt{j, i});
      }
    }
  }
  n = int((ps).size());
  return 1;
}
int pos_at(const vi& t, const int x) {
  int p = lower_bound(begin(t), end(t), x) - t.begin();
  return p;
}
void solve() {
  for (auto& p : ps) {
    p = p.trans();
  }
  ll ans = 0;
  for (int it = int(0); it < int(2); ++it) {
    vi xs;
    for (const auto& p : ps) {
      xs.push_back(p.x);
    }
    sort(begin(xs), end(xs)),
        xs.resize(unique(begin(xs), end(xs)) - xs.begin());
    vvi ys(int((xs).size()));
    for (const auto& p : ps) {
      int px = pos_at(xs, p.x);
      ys[px].push_back(p.y);
    }
    for (auto& col : ys) {
      sort(begin(col), end(col)),
          col.resize(unique(begin(col), end(col)) - col.begin());
    }
    for (const int x : xs) {
      const int px = pos_at(xs, x);
      for (int i = int(0); i < int(int((ys[px]).size())); ++i) {
        for (int j = int(i + 1); j < int(int((ys[px]).size())); ++j) {
          int y1___ = ys[px][i];
          int y2 = ys[px][j];
          const int dist = y2 - y1___;
          assert(dist > 0);
          for (int dx = -dist; dx <= dist; dx += 2 * dist) {
            const int xx = x + dx;
            const int pxx = pos_at(xs, xx);
            if (!(0 <= pxx && pxx < int((xs).size()) && xs[pxx] == xx)) {
              continue;
            }
            int p1;
            if (it == 0) {
              p1 = upper_bound(begin(ys[pxx]), end(ys[pxx]), y1___) -
                   ys[pxx].begin();
            } else {
              p1 = lower_bound(begin(ys[pxx]), end(ys[pxx]), y1___) -
                   ys[pxx].begin();
            }
            int p2;
            if (it == 0) {
              p2 = upper_bound(begin(ys[pxx]), end(ys[pxx]), y2 - 1) -
                   ys[pxx].begin();
              --p2;
            } else {
              p2 = upper_bound(begin(ys[pxx]), end(ys[pxx]), y2) -
                   ys[pxx].begin();
              --p2;
            }
            ans += max(0, p2 - p1 + 1);
            if (0) {
              for (int j = p1; j <= p2; ++j) {
                ;
              }
            }
          }
        }
      }
    }
    for (auto& p : ps) {
      swap(p.x, p.y);
    }
  }
  cout << ans << endl;
}
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  cout.tie(nullptr);
  cout.precision(12);
  cout << fixed;
  while (read()) {
    solve();
  }
  return 0;
}
