output_description: Print the number of Taro's paths from Square (1, 1) to (H, W), modulo 10^9 +
  7.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W
      a_{1, 1}\ldotsa_{1, W}
      :
      a_{H, 1}\ldotsa_{H, W}
attempt: """ ===============================
  	-- @uthor : Kaleab Asfaw
  	-- Handle : kaleabasfaw2010
  	-- Bio    : High-School Student
  	==============================="""
  
  # Fast IO
  import sys
  import os
  from io import BytesIO, IOBase
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  # Others
  # from math import floor, ceil, gcd
  # from decimal import Decimal as d
  mod = 10**9 + 7
  
  
  def lcm(x, y):
      return (x * y) / (gcd(x, y))
  
  
  def fact(x, mod=mod):
      ans = 1
      for i in range(1, x + 1):
          ans = (ans * i) % mod
      return ans
  
  
  def arr2D(n, m, default=0):
      lst = []
      for i in range(n):
          temp = [default] * m
          lst.append(temp)
      return lst
  
  
  def sortDictV(x):
      return {k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
  
  
  def solve(n, m, grid):
      dp = arr2D(n, m)
      dp[0][0] = 1
      for i in range(n):
          for j in range(m):
              if grid[i][j] == "." and (
                  (i > 0 and grid[i - 1][j] == ".") or (j > 0 and grid[i][j - 1] == ".")
              ):
                  dp[i][j] = (dp[i][j - 1] + dp[i - 1][j]) % mod
      return dp[n - 1][m - 1]
  
  
  n, m = list(map(int, input().split()))
  grid = []
  for i in range(n):
      grid.append(input())
  print(solve(n, m, grid))
  
problem_description: Statement
  
  There is a grid with H horizontal rows and W vertical columns. Let (i, j)
  denote the square at the i-th row from the top and the j-th column from the
  left.
  
  For each i and j (1 \leq i \leq H, 1 \leq j \leq W), Square (i, j) is
  described by a character a_{i, j}. If a_{i, j} is `.`, Square (i, j) is an
  empty square; if a_{i, j} is `#`, Square (i, j) is a wall square. It is
  guaranteed that Squares (1, 1) and (H, W) are empty squares.
  
  Taro will start from Square (1, 1) and reach (H, W) by repeatedly moving right
  or down to an adjacent empty square.
  
  Find the number of Taro's paths from Square (1, 1) to (H, W). As the answer
  can be extremely large, find the count modulo 10^9 + 7.
samples: [{"input": "3 4\n    ...#\n    .#..\n    ....", "output": "3\n    \n\nThere are three paths as follows:\n\n![](https://img.atcoder.jp/dp/grid_0_0_muffet.png)\n\n* * *"}, {"input": "5 2\n    ..\n    #.\n    ..\n    .#\n    ..", "output": "0\n    \n\nThere may be no paths.\n\n* * *"}, {"input": "5 5\n    ..#..\n    .....\n    #...#\n    .....\n    ..#..", "output": "24\n    \n\n* * *"}, {"input": "20 20\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................\n    ....................", "output": "345263555\n    \n\nBe sure to print the count modulo 10^9 + 7."}]