object Main extends App {

  val (h, w) = readLine.split(" ").map(_.toInt) match {
    case Array(h, w) => (h, w)
  }

  case class Position(i: Int, j: Int)

  case class Point(position: Position,
                   isBlack: Boolean,
                   nexts: Seq[Position] = Nil)

  case class Field(charArrArr: Array[Array[Char]]) {
    val points: Seq[Point] = charArrArr.zipWithIndex
      .filterNot(t => t._2 == 0 || t._2 == h + 1)
      .flatMap {
        case (charArr, i) =>
          charArr.zipWithIndex
            .filterNot(t => t._2 == 0 || t._2 == w + 1)
            .flatMap {
              case (c, j) =>
                def nexts(isBlack: Boolean): Seq[Position] =
                  Seq((i, j - 1), (i, j + 1), (i - 1, j), (i + 1, j))
                    .flatMap(p =>
                      charArrArr(p._1)(p._2) match {
                        case '#' if !isBlack => Some(Position(p._1, p._2))
                        case '.' if isBlack  => Some(Position(p._1, p._2))
                        case _               => None
                    })

                c match {
                  case '#' => Some(Point(Position(i, j), true, nexts(true)))
                  case '.' => Some(Point(Position(i, j), false, nexts(false)))
                  case _   => None
                }
            }
      }

    def find(p: Position): Point = points.find(_.position == p).get

    def nextWps(bp: Point,
                prevWps: Seq[Point] = Seq(),
                prevBps: Seq[Point] = Seq()): Seq[Point] =
      bp.nexts
        .filterNot(wpPositions => prevWps.exists(_.position == wpPositions))
        .map(find) match {
        case Nil => Seq()
        case wps =>
          wps ++ wps.flatMap(wp => nextBps(wp, prevWps, bp +: prevBps))
      }

    def nextBps(wp: Point,
                prevWps: Seq[Point] = Seq(),
                prevBps: Seq[Point] = Seq()): Seq[Point] =
      wp.nexts
        .filterNot(bpPositions => prevBps.exists(_.position == bpPositions))
        .map(find) match {
        case Nil => Seq()
        case bps => bps.flatMap(bp => nextWps(bp, wp +: prevWps, prevBps))
      }

  }

  val charArrList =
    List(Array.fill(w + 2)('x')) ++ (1 to h)
      .map(_ => ('x' + readLine + 'x').toCharArray)
      .toList ++ List(Array.fill(w + 2)('x'))

  val field = Field(charArrList.toArray)
  val count = field.points
    .filter(_.isBlack)
    .map(bp => field.nextWps(bp).map(_.position).distinct.length)
    .sum
  println(count)

}