#include <bits/stdc++.h>
using namespace std;
 
const int MOD = 1'000'000'007;
 
int addmod(int a, int b) {
    int s = a + b;
    if (s >= MOD) s -= MOD;
    return s;
}
int submod(int a, int b) {
    int s = a - b;
    if (s < 0) s += MOD;
    return s;
}
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    if (!(cin >> n >> m)) return 0;
    vector<string> g(n + 1);
    for (int i = 1; i <= n; ++i) {
        string s;  cin >> s;
        g[i] = " " + s;                 // 1‑based
    }
    if (n == 1 && m == 1) {            // only the start cell
        cout << 1 << '\n';
        return 0;
    }
 
    /*  rowRocks[i][j] = number of rocks in row i strictly to the right of column j
        colRocks[i][j] = number of rocks in column j strictly below row i          */
    vector<vector<int>> rowRocks(n + 2, vector<int>(m + 2, 0));
    vector<vector<int>> colRocks(n + 2, vector<int>(m + 2, 0));
 
    for (int i = 1; i <= n; ++i) {
        int cnt = 0;
        for (int j = m; j >= 1; --j) {
            rowRocks[i][j] = cnt;
            if (g[i][j] == 'R') ++cnt;
        }
    }
    for (int j = 1; j <= m; ++j) {
        int cnt = 0;
        for (int i = n; i >= 1; --i) {
            colRocks[i][j] = cnt;
            if (g[i][j] == 'R') ++cnt;
        }
    }
 
    /*  difference tables for range additions   */
    vector<vector<int>> diffR(n + 2, vector<int>(m + 2, 0));
    vector<vector<int>> diffD(n + 2, vector<int>(m + 2, 0));
 
    // virtual start state
    int startRight = m - rowRocks[1][1];
    if (startRight >= 2) {
        diffR[1][2] = addmod(diffR[1][2], 1);
        diffR[1][startRight + 1] = submod(diffR[1][startRight + 1], 1);
    }
    int startDown = n - colRocks[1][1];
    if (startDown >= 2) {
        diffD[2][1] = addmod(diffD[2][1], 1);
        diffD[startDown + 1][1] = submod(diffD[startDown + 1][1], 1);
    }
 
    vector<int> dpDPrev(m + 2, 0), dpDCur(m + 2, 0);
    int dpR_last = 0;                     // dpR[n][m]
 
    for (int i = 1; i <= n; ++i) {
        /* column prefix sum → dpD[i][*] */
        for (int j = 1; j <= m; ++j) {
            int val = dpDPrev[j] + diffD[i][j];
            if (val >= MOD) val -= MOD;
            dpDCur[j] = val;
        }
 
        int curR = 0;                     // row prefix sum → dpR[i][j]
        for (int j = 1; j <= m; ++j) {
            curR += diffR[i][j];
            if (curR >= MOD) curR -= MOD;
            if (curR < 0) curR += MOD;    // safety, should not happen
 
            /*  transition from a horizontal state → vertical segment  */
            if (curR) {
                int maxRow = n - colRocks[i][j];          // downLimit
                if (maxRow >= i + 1) {
                    diffD[i + 1][j] = addmod(diffD[i + 1][j], curR);
                    diffD[maxRow + 1][j] = submod(diffD[maxRow + 1][j], curR);
                }
            }
 
            /*  transition from a vertical state → horizontal segment  */
            int valD = dpDCur[j];
            if (valD) {
                int maxCol = m - rowRocks[i][j];          // rightLimit
                if (maxCol >= j + 1) {
                    diffR[i][j + 1] = addmod(diffR[i][j + 1], valD);
                    diffR[i][maxCol + 1] = submod(diffR[i][maxCol + 1], valD);
                }
            }
 
            if (i == n && j == m) dpR_last = curR;
        }
        dpDPrev.swap(dpDCur);            // next row
    }
 
    int answer = addmod(dpR_last, dpDPrev[m]);   // dpD[n][m] is in dpDPrev[m]
    cout << answer << '\n';
    return 0;
}