use std::cmp::{max, min};
use std::collections::BTreeSet;

const X: usize = 400;
const W: usize = X * 2;

fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());

    let h: usize = sc.read();
    let w: usize = sc.read();

    let board: Vec<Vec<_>> = (0..h).map(|_| sc.chars()).collect();
    let mut board2 = vec![vec![' '; w]; h];
    for i in 0..h {
        for j in 0..w {
            board2[i][j] = board[i][w - 1 - j];
        }
    }

    let ans1 = solve(&board);
    let ans2 = solve(&board2);

    let mut set = BTreeSet::new();
    for i in 0..h {
        for j in 0..w {
            if board[i][j] != '#' {
                continue;
            }
            for d in 1..X {
                if i + d >= h || j + d >= w {
                    break;
                }
                if board[i + d][j + d] != '#' {
                    continue;
                }

                let v = vec![(i, j), (i + d, j + d)];

                if j >= d && i + d < h && board[i + d][j - d] == '#' {
                    let mut v = v.clone();
                    v.push((i + d, j - d));
                    v.sort();
                    set.insert(v);
                }
                if i >= d && j + d < w && board[i - d][j + d] == '#' {
                    let mut v = v.clone();
                    v.push((i - d, j + d));
                    v.sort();
                    set.insert(v);
                }
                if j + 2 * d < w && board[i][j + 2 * d] == '#' {
                    let mut v = v.clone();
                    v.push((i, j + 2 * d));
                    v.sort();
                    set.insert(v);
                }
                if i + 2 * d < h && board[i + 2 * d][j] == '#' {
                    let mut v = v.clone();
                    v.push((i + 2 * d, j));
                    v.sort();
                    set.insert(v);
                }
            }
        }
    }

    let ans = ans1 + ans2 - set.len();
    println!("{}", ans);
}

fn solve(s: &Vec<Vec<char>>) -> usize {
    let mut board = vec![vec!['.'; W]; W];
    for i in 0..s.len() {
        for j in 0..s[i].len() {
            board[i + X][j] = s[i][j];
        }
    }

    let mut sum = vec![vec![0; W + 1]; W];
    for i in 0..W {
        for j in 0..W {
            if i + j >= W {
                break;
            }
            sum[i][j + 1] = sum[i][j] + if board[i + j][j] == '#' { 1 } else { 0 };
        }
    }

    let mut ans = 0;
    for index in 0..W {
        for i in 0..W {
            if index + i >= W {
                break;
            }
            if board[index + i][i] != '#' {
                continue;
            }
            for j in (i + 1)..W {
                if index + j >= W {
                    break;
                }
                if board[index + j][j] != '#' {
                    continue;
                }

                let d = j - i;
                if index >= 2 * d {
                    ans += sum[index - 2 * d][min(j + d + 1, W)] - sum[index - 2 * d][j];
                }
                if index + 2 * d < W {
                    ans += sum[index + 2 * d][i + 1] - sum[index + 2 * d][max(i, d) - d];
                }
            }
        }
    }
    ans
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> Self {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
