Problem:
Score : 100 points

Problem 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.

Constraints

H and W are integers.

2 \leq H, W \leq 1000

a_{i, j} is . or #.

Squares (1, 1) and (H, W) are empty squares.

Input

Input is given from Standard Input in the following format:

H W
a_{1, 1}\ldotsa_{1, W}
:
a_{H, 1}\ldotsa_{H, W}

Output

Print the number of Taro's paths from Square (1, 1) to (H, W), modulo 10^9 + 7.

Sample Input 1

3 4
...#
.#..
....

Sample Output 1

3

There are three paths as follows:

Sample Input 2

5 2
..
#.
..
.#
..

Sample Output 2

0

There may be no paths.

Sample Input 3

5 5
..#..
.....
#...#
.....
..#..

Sample Output 3

24

Sample Input 4

20 20
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................
....................

Sample Output 4

345263555

Be sure to print the count modulo 10^9 + 7.

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using BitArray = System.Collections.BitArray;
using BigInteger = System.Numerics.BigInteger;

namespace AtCoderProject
{
    public class Program
    {
        public object Calc()
        {
            var line = consoleReader.Split.Int;
            var H = line[0];
            var W = line[1];
            var grid = new bool[H][];
            foreach (var item in consoleReader.Repeat(H).String.Select((l, i) => new { Line = l, Index = i }))
            {
                grid[item.Index] = item.Line.Select(c => c == '.').ToArray();
            }

            var dp = new Mod[H, W];
            dp[0, 0] = 1;
            for (int h = 1; h < H; h++)
            {
                dp[h, 0] = grid[h][0] ? dp[h - 1, 0] : 0;
            }
            for (int w = 1; w < W; w++)
            {
                dp[0, w] = grid[0][w] ? dp[0, w - 1] : 0;
            }

            for (int h = 1; h < H; h++)
                for (int w = 1; w < W; w++)
                {
                    if (grid[h][w])
                    {
                        dp[h, w] = dp[h - 1, w] + dp[h, w - 1];
                    }
                    else
                    {
                        dp[h, w] = 0;
                    }
                }
            return dp[H - 1, W - 1];
        }
        struct Mod : IEquatable<Mod>
        {
            public const long mod = 1000000007;
            public readonly long val;
            public Mod(long val) { this.val = val; }
            public override bool Equals(object obj) => (obj is Mod) ? this == ((Mod)obj) : false;
            public bool Equals(Mod obj) => this == obj;
            public override int GetHashCode() => val.GetHashCode();
            public override string ToString() => val.ToString();
            public static implicit operator Mod(long x) => new Mod(x);
            public static Mod operator +(Mod x, Mod y) => (x.val + y.val) % mod;
            public static Mod operator -(Mod x, Mod y) => x.val >= y.val ? (x.val - y.val) % mod : (x.val - y.val) % mod + mod;
            public static Mod operator *(Mod x, Mod y) => (x.val * y.val) % mod;
            public static Mod operator /(Mod x, Mod y) => x * y.Inverse();
            public static bool operator ==(Mod x, Mod y) => x.val == y.val;
            public static bool operator !=(Mod x, Mod y) => x.val != y.val;
            public Mod Inverse()
            {
                long a = val, b = mod, u = 1, v = 0;
                while (b > 0)
                {
                    long t = a / b;
                    var b2 = a - t * b;
                    a = b; b = b2;
                    var v2 = u - t * v;
                    u = v; v = v2;
                }
                u %= mod;
                if (u < 0) u += mod;
                return u;
            }
            public static Mod Pow(Mod x, int y)
            {
                Mod res = 1;
                for (; y > 0; y >>= 1)
                {
                    if ((y & 1) == 1) res *= x;
                    x *= x;
                }
                return res;
            }

            public static Factor CreateFactor(int max) => new Factor(max);
            public class Factor
            {
                private readonly Mod[] fac, finv;
                public Factor(int max)
                {
                    var inv = new Mod[max];
                    fac = new Mod[max]; finv = new Mod[max];
                    fac[0] = fac[1] = 1;
                    finv[0] = finv[1] = 1;
                    inv[1] = 1;
                    for (int i = 2; i < max; i++)
                    {
                        fac[i] = fac[i - 1] * i;
                        inv[i] = mod - inv[mod % i].val * (mod / i) % mod;
                        finv[i] = finv[i - 1] * inv[i];
                    }
                }

                // 二項係数計算
                public Mod Combine(int n, int k)
                {
                    if (n < k) return 0;
                    if (n < 0 || k < 0) return 0;
                    return fac[n] * finv[k] * finv[n - k];
                }

                public Mod Factorial(int n) => fac[n];
                public Mod FactorialInvers(int n) => finv[n];
            }
        }

        #region いつもの
        private readonly ConsoleReader consoleReader;
        public Program(ConsoleReader consoleReader) { this.consoleReader = consoleReader; }
        static void Main() => Console.WriteLine(new Program(new ConsoleReader()).Calc()); static string AllLines<T>(IEnumerable<T> source) => string.Join("\n", source);
        #endregion
    }

#pragma warning disable
    public class ConsoleReader { public class SplitLine { string[] splited; public SplitLine(string line) { splited = line.Split(); } public string[] String => splited.ToArray(); public int[] Int => splited.Select(int.Parse).ToArray(); public long[] Long => splited.Select(long.Parse).ToArray(); public ulong[] ULong => splited.Select(ulong.Parse).ToArray(); public double[] Double => splited.Select(double.Parse).ToArray(); } public class RepeatLine { ConsoleReader reader; int num; public RepeatLine(ConsoleReader reader, int num) { this.reader = reader; this.num = num; } public IEnumerable<string> String { get { for (int i = 0; i < num; i++) yield return reader.String; } } public IEnumerable<int> Int { get { for (int i = 0; i < num; i++) yield return reader.Int; } } public IEnumerable<long> Long { get { for (int i = 0; i < num; i++) yield return reader.Long; } } public IEnumerable<string[]> Split { get { for (int i = 0; i < num; i++) yield return reader.Split.String; } } public IEnumerable<int[]> SplitInt { get { for (int i = 0; i < num; i++) yield return reader.Split.Int; } } } public virtual string String => Console.ReadLine(); public int Int => int.Parse(String); public long Long => long.Parse(String); public ulong ULong => ulong.Parse(String); public double Double => double.Parse(String); public SplitLine Split => new SplitLine(String); public RepeatLine Repeat(int count) => new RepeatLine(this, count); }
}