stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define ll long long

#define Test int t;cin>>t;while(t--)

#define PI acos(-1)

#define endl "\n"

#define fx(x) fixed<<setprecision(x)

#define sz(s) (int)s.size()

#define all(v) (v).begin(),(v).end()

#define allr(v) (v).rbegin(),(v).rend()

#define mem(a,n) memset((a),n,sizeof (a))

const double eps=1e-9;

const int mod=1e9+7;

int dx[]={-1,-1,-1,0,0,1,1,1};

int dy[]={-1,0,1,-1,1,-1,0,1};

ll gcd(ll x,ll y) {return(!y)?x:gcd(y,x%y);}

ll lcm(ll x,ll y) {return((x/gcd(x,y))*y);}

using namespace std;

void fast(){

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

}

int dp[1001][1001];

int n,m;

char a[1001][1001];

bool valid(int i,int j){

    return (i>=0&&i<n&&j>=0&&j<m&&a[i][j]!='#');

}

int solve(int i,int j){

    if(i==n-1&&j==m-1)return 1;

    int &ret=dp[i][j];

    if(~ret)return ret;

    ret=0;

    if(valid(i+1,j))ret+=solve(i+1,j)%mod;

    if(valid(i,j+1))ret+=solve(i,j+1)%mod;

    return ret%mod;

}

int main()

{

    mem(dp,-1);

    cin>>n>>m;

    for(int i=0;i<n;i++){

        for(int j=0;j<m;j++){

            cin>>a[i][j];

        }

    }

    cout<<solve(0,0);

    return 0;

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define  ll long long int

#define mx 1005

ll b[mx],c[mx];

ll dp[mx][mx];

ll dp1[mx][mx];

ll a[mx][mx];

ll n;



int main()

{

    ll n,m;

    cin>>n>>m;

    char a[n+6][m+6];

    for(int i=1;i<=n;i++){

        for(int j=1;j<=m;j++) cin>>a[i][j];

    }

    for(int i=1;i<=n;i++){

        for(int j=1;j<=m;j++){

            if(a[i][j]=='#'){

                dp[i][j]=0;

                continue;

            }

            if(i==1 && j==1) dp[i][j]=1;

            else if(i==1 || j==1){

                if(i==1){

                    dp[i][j]=dp[i][j-1];

                }

                else{

                    dp[i][j]=dp[i-1][j];

                }

            }

            else dp[i][j]=dp[i-1][j]+dp[i][j-1];



            dp[i][j]%=1000000007;

        }

    }

    cout<<dp[n][m]<<endl;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#define inf 1000000007

#define N 1007

using namespace std;



int h, w;

char path[N][N];

long long mem[N][N];



long long dp(int i, int j)

{

    if(i == (h - 1) && j == (w - 1))

        return 1;

    if(mem[i][j] != -1)

        return mem[i][j];

    long long ans = 0;

    if((j + 1) != w && path[i][j + 1] != '#')

        ans = ((ans % inf) + (dp(i, j + 1) % inf)) % inf;

    if((i + 1) != h && path[i + 1][j] != '#')

        ans = ((ans % inf) + (dp(i + 1, j) % inf)) % inf;

    mem[i][j] = ans;

    return ans;

}



int main()

{

    //freopen("input.txt", "r", stdin);

    //freopen("output.txt", "w", stdout);

    cin >> h >> w;

    for(int i = 0;i < h;i++)

        for(int j = 0;j < w;j++)

            cin >> path[i][j];

    memset(mem, -1, sizeof(mem));

    cout << dp(0, 0) << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define  ll long long int

#define mx 1005

ll b[mx],c[mx];

ll dp[mx][mx];

ll dp1[mx][mx];

ll a[mx][mx];

ll n;



int main()

{

    ll n,m;

    cin>>n>>m;

    char a[n+6][m+6];

    for(int i=1;i<=n;i++){

        for(int j=1;j<=m;j++) cin>>a[i][j];

    }

    for(int i=1;i<=n;i++){

        for(int j=1;j<=m;j++){

            if(a[i][j]=='#'){

                dp[i][j]=0;

                continue;

            }

            if(i==1 && j==1) dp[i][j]=1;

            else if(i==1 || j==1){

                if(i==1){

                    dp[i][j]=dp[i][j-1];

                }

                else{

                    dp[i][j]=dp[i-1][j];

                }

            }

            else dp[i][j]=dp[i-1][j]+dp[i][j-1];



            dp[i][j]%=1000000007;

        }

    }

    cout<<dp[n][m]<<endl;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

const int mod = 7 + 1e9;

int h, w, dp[1000][1000]={};

bool grid[1000][1000];

int f(int i = 0 , int j = 0 )

{

    if( i == h || j == w || grid[i][j] )

        return 0;

    if( i == h-1 && j == w-1)

        return 1;

    int &d = dp[i][j];

    if( d != -1 ) return d;

    return d = (f(i+1,j)%mod + f(i,j+1)%mod)%mod;

}

int main()

{

    memset(dp,-1,sizeof dp);

    cin >> h >> w;

    for(int i=0;i<h;++i)

        for(int j=0;j<w;++j)

        {

            char t; cin >> t;

            grid[i][j] = t == '.' ? 0 : 1 ;

        }

    cout << f();

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 1e5, m = 1e9 + 7;

int h, w, dg[1000][1000];

char g[1000][1000];

int main()

{

    cin >> h >> w;

    for(int i=0; i<h; ++i)

        for(int j=0; j<w; ++j)

            cin >> g[i][j];

    for(int i=0; i<w; ++i){

        if( g[0][i] == '#' )

            break;

        dg[0][i] = 1;

    }

    for(int i=0; i<h; ++i){

        if( g[i][0] == '#' )

            break;

        dg[i][0] = 1;

    }

    for(int i=1; i<h; ++i)

        for(int j=1; j<w; ++j){

            dg[i][j] = (dg[i-1][j] + dg[i][j-1]) < m ? (dg[i-1][j] + dg[i][j-1]) : (dg[i-1][j] + dg[i][j-1] - m);

            if( g[i][j] == '#' )

                dg[i][j] = 0;

        }

    cout << dg[h-1][w-1];

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

 

using namespace std;

 

#define BOOST        std::ios::sync_with_stdio(false);  cin.tie(NULL); cout.tie(NULL);

#define sp           <<" "<<

#define ll           long long

#define ld           long double

#define For(i,k,n)   for(ll i=k;i<n;i++)

#define Ford(i,n)    for(ll i=n-1;i>=0;i--)

#define AZI(i,x)     for(auto i=x.begin();i!=x.end();i++)

#define AZ(x)        x.begin(),x.end()

#define P(x,y)       pair < x,y >

#define V(x)         vector < x >

#define fi           first

#define se           second

#define pb           push_back

#define mp           make_pair

#define PI           3.14159265358979323846264338327950288419716939937510

 

const ll mod=1e9+7,N=1e6+5;



int h,w;

ll dp[1005][1005];

char grid[1005][1005]={};



ll no_of_paths(int r, int c)

{

    if(r>h || c>w)

        return 0;



    if(dp[r][c]!=-1)  return dp[r][c];



    if(grid[r][c]=='#')    return dp[r][c] = 0;



    else return dp[r][c] = ( (no_of_paths(r+1,c)%mod + no_of_paths(r,c+1)%mod) )%mod;

}



int main() 

{ 

    BOOST



    cin>>h>>w;



    memset(dp,-1,sizeof(dp));



    for(int i=1; i<=h; i++)

        for(int j=1; j<=w; j++)

            cin>>grid[i][j];



    dp[h][w] = 1;



    cout<<no_of_paths(1,1)<<"\n";

    

    return 0; 

} 

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

 

using namespace std;

 

#define BOOST        std::ios::sync_with_stdio(false);  cin.tie(NULL); cout.tie(NULL);

#define sp           <<" "<<

#define ll           long long

#define ld           long double

#define For(i,k,n)   for(ll i=k;i<n;i++)

#define Ford(i,n)    for(ll i=n-1;i>=0;i--)

#define AZI(i,x)     for(auto i=x.begin();i!=x.end();i++)

#define AZ(x)        x.begin(),x.end()

#define P(x,y)       pair < x,y >

#define V(x)         vector < x >

#define fi           first

#define se           second

#define pb           push_back

#define mp           make_pair

#define PI           3.14159265358979323846264338327950288419716939937510

 

const ll mod=1e9+7,N=1e6+5;



int h,w;

ll dp[1005][1005]={};

char grid[1005][1005]={};



int main() 

{ 

    BOOST



    cin>>h>>w;



    // memset(dp,-1,sizeof(dp));



    for(int i=1; i<=h; i++)

        for(int j=1; j<=w; j++)

            cin>>grid[i][j];



    dp[h][w] = 1;



    for(int i=h; i>0; i--)

    {

        for(int j=w; j>0; j--)

        {

            if(i==h && j==w)

                continue;



            else if(grid[i][j]=='#')

                dp[i][j] = 0;



            else

                dp[i][j] = (dp[i+1][j]%mod + dp[i][j+1]%mod)%mod;

        }

    }

    

    cout<<dp[1][1]<<"\n";

    

    return 0; 

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

 

using namespace std;

 

#define sf(n) scanf("%d", &n)

#define pd(n) printf("%.12lf", n)

#define pf(n) printf("%d", n)

#define p() printf("\n")

#define ps() printf(" ")

#define ll long long

#define ull unsigned long long

#define MAX 1e9

const int mod = 1000 * 1000 * 1000 + 7;

#define ex 1e18

#define dbl 2e09

#define qu(q) queue<int> q

#define pqu(q) priority_queue<int> q

#define len(s) s.length()

#define sz(x) int(x.size())

#define pb(x) push_back(x)

#define all(x) x.begin(), x.end()

#define rall(x) x.rbegin(), x.rend()

#define F first

#define S second

#define clr(x) x.clear()

#define LOG(x) std::cout << x << std::endl;

 

const int INF = 0x3f3f3f3f;

const ll LL_INF = 0x3f3f3f3f3f3f3f3f;

const double PI = 3.14159265359;

 

int dx[6] = {-1,-1,0,0,1,1};

int dy[6] = {-1,0,-1,1,0,1};



int w,h;

char a[1005][1005];

int dp[1005][1005];



int solve(int i,int j){

    if(i==(h-1)and j==(w-1))

        return 1;

    if(i>=h or j>=w)

        return 0;

    int &ret=dp[i][j];

    if(~ret)return ret;

    ret=0;

    if((i+1)<h and a[i+1][j]!='#'){

        ret+=solve(i+1,j)%mod;

    }

    if((j+1)<w and a[i][j+1]!='#'){

        ret+=solve(i,j+1)%mod;

    }

    return ret%mod;

}





int main(){

    cin>>h>>w;

    for(int i=0;i<h;++i){

        for(int j=0;j<w;++j){

            cin>>a[i][j];

        }

    }

    memset(dp,-1,sizeof dp);

    cout<<solve(0,0)<<endl;



    return 0;

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define ll long long int

ll mod  = 1000000000+7;

char g[1000+5][1005];

ll dp[1005][1005];

int main(){

int n, m;

cin >> n >> m;

for(int i=0; i<n; i++)

    for(int j=0; j<m; j++)

        cin >> g[i][j];



for(int i=0;i<n; i++) {

      if (g[i][0]=='#') break;

    dp[i][0] = 1;

}

for(int j=0; j<m; j++){

    if(g[0][j]=='#') break;

     dp[0][j] = 1;

}



for(int i=1; i<n; i++){

    for(int j=1; j<m; j++){

            if(g[i][j]=='#') continue;

        dp[i][j] = (dp[i-1][j]+dp[i][j-1]) %mod;

        //cout << i<<" "<<j <<" "<< dp[i][j] <<" ";

    }

    //cout << endl;

}

cout << dp[n-1][m-1];

return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#define _CRT_SECURE_NO_WARNINGS

#include<bits/stdc++.h>

#include<iostream>

#include<algorithm>

#include<iomanip>

#include<string>

#include<cmath>

#include<vector>

#include<set>

#include<queue>

#include<stack>

#include<fstream>

#include<map>

#include<bitset>

#include<unordered_map>

#include<cstring>

#include<cctype>

using namespace std;

#define  ll long long

#define  ull unsigned long long

#define  ul unsigned long

#define all(v) v.begin(),v.end()

#define sz(n) (int)n.size()

#define pb(s) push_back(s);

#define format(n) fixed<<setprecision(n)

#define finl "\n"

#define Mohammed_Atef_Hassan fast();

#define mod 1000000007

#define INF LLONG_MAX

#define PI acos(-1)

#define clr(dp,n) memset(dp,n,sizeof dp)

#define ex(n) return cout<<n<<finl,0;

int dx[] = { 0, 1, 0, -1, 1, 1, -1, -1 };

int dy[] = { 1, 0, -1, 0, 1, -1, 1, -1 };

ll fix_mod(ll x, ll y)

{

	return (y + x % y) % y;

}

void fast() {

	std::ios_base::sync_with_stdio(false);

	cin.tie(nullptr); cout.tie(nullptr);

}

char g[1001][1001]; int n, m;

ll mem[1001][1001];

ll solve(int x, int y)

{

	if (x == n || y == m||g[x][y]=='#')return 0;

	if (x == n - 1 && y == m - 1)return 1;

	ll& ret = mem[x][y];

	if(~ret)return ret;

	 ret = solve(x + 1, y) + solve(x, y + 1);

	 return ret %= 1000000007;

}

int main()

{

	Mohammed_Atef_Hassan

		clr(mem, -1);

		cin >> n >> m;

	for (int i = 0; i < n; i++)

		for (int j = 0; j < m; j++)

			cin >> g[i][j];

	cout << solve(0, 0) << finl;

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define ll long long int

ll mod  = 1000000000+7;

char g[1000+5][1005];

ll dp[1005][1005];

int main(){

int n, m;

cin >> n >> m;

for(int i=0; i<n; i++)

    for(int j=0; j<m; j++)

        cin >> g[i][j];



for(int i=0;i<n; i++) {

      if (g[i][0]=='#') break;

    dp[i][0] = 1;

}

for(int j=0; j<m; j++){

    if(g[0][j]=='#') break;

     dp[0][j] = 1;

}



for(int i=1; i<n; i++){

    for(int j=1; j<m; j++){

            if(g[i][j]=='#') continue;

        dp[i][j] = (dp[i-1][j]+dp[i][j-1]) %mod;

        //cout << i<<" "<<j <<" "<< dp[i][j] <<" ";

    }

    //cout << endl;

}

cout << dp[n-1][m-1];

return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define ull unsigned long long

#define INF 1e18

#define REPL(i,a,b) for(int i=a;i<a;++i)

#define REPLE(i,a,b) for(int i=a;i<=a;++i)

typedef vector<int> vi;

typedef vector<ll> vll;

typedef pair<int,int> pi;



#define M_PI 3.14159265358979323846



char a[1020][1020];

const int oo = 1e9+10;

const int mod = 1e9+7;

ll memo[1020][1020];



ll gcd(ll a, ll b){return a==0 ? b : gcd(b%a, a);}



int add(int a, int b){

	return ((a+b) < mod ? a+b : a+b - mod);

}



int h,w;

ll dp(int i, int j){

	if(i == h-1 && j == w-1)return 1;

	if(memo[i][j] != -1)return memo[i][j];

	ll ans = 0;

	if(i+1 < h && a[i+1][j] != '#'){

		ans = dp(i+1,j);

	}

	if(j+1 < w &&  a[i][j+1] != '#'){

		ans = add(ans, dp(i,j+1));

	}

	return memo[i][j] = ans;

}



void solve(){

	cin>>h>>w;

	for(int i = 0 ; i < h; ++i){

		for(int j = 0 ; j < w ; ++j){

			cin >> a[i][j];

		}

	}	

	memset(memo, -1, sizeof memo);

	cout << dp(0,0) << '\n';

}

int main(){   

    ios::sync_with_stdio(0);cin.tie(0);

	int t=1;

	while(t--){

		solve();

	}

}  
















// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define ll long long int

ll mod  = 1000000000+7;

char g[1000+5][1005];

ll dp[1005][1005];

int main(){

int n, m;

cin >> n >> m;

for(int i=0; i<n; i++)

    for(int j=0; j<m; j++)

        cin >> g[i][j];



for(int i=0;i<n; i++) {

      if (g[i][0]=='#') break;

    dp[i][0] = 1;

}

for(int j=0; j<m; j++){

    if(g[0][j]=='#') break;

     dp[0][j] = 1;

}



for(int i=1; i<n; i++){

    for(int j=1; j<m; j++){

            if(g[i][j]=='#') continue;

        dp[i][j] = (dp[i-1][j]+dp[i][j-1]) %mod;

        //cout << i<<" "<<j <<" "<< dp[i][j] <<" ";

    }

    //cout << endl;

}

cout << dp[n-1][m-1];

return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp> // Common file

#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;

using namespace __gnu_pbds;

using ll = long long;

using _TYPE = int;

typedef tree< _TYPE, null_type, less< _TYPE >, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

#define IO ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)



int h, w;

const int MAX = 1002;

const int MOD = (int) 1e9 + 7;

char grid[MAX][MAX];

int memo[MAX][MAX];



int dp(int r, int c) {

	if((r >= h) || (c >= w) || (grid[r][c] == '#'))

		return 0;

	if(r == h - 1 && c == w - 1)

		return 1;

	int &rt = memo[r][c];

	if(rt != -1)

		return (rt % MOD);

	rt = dp(r + 1, c) % MOD;

	rt += dp(r, c + 1) % MOD;

	return (rt % MOD);

}



int main() {

    IO;

    cin >> h >> w;

    for(int i = 0; i < h; i++) {

    	for(int j = 0; j < w; j++)

    		cin >> grid[i][j];

    }

    memset(memo, -1, sizeof memo);

    cout << dp(0, 0) % MOD;

    return 0;

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define ll long long int

ll mod  = 1000000000+7;

char g[1000+5][1005];

ll dp[1005][1005];

int main(){

int n, m;

cin >> n >> m;

for(int i=0; i<n; i++)

    for(int j=0; j<m; j++)

        cin >> g[i][j];



for(int i=0;i<n; i++) {

      if (g[i][0]=='#') break;

    dp[i][0] = 1;

}

for(int j=0; j<m; j++){

    if(g[0][j]=='#') break;

     dp[0][j] = 1;

}



for(int i=1; i<n; i++){

    for(int j=1; j<m; j++){

            if(g[i][j]=='#') continue;

        dp[i][j] = (dp[i-1][j]+dp[i][j-1]) %mod;

        //cout << i<<" "<<j <<" "<< dp[i][j] <<" ";

    }

    //cout << endl;

}

cout << dp[n-1][m-1];

return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define oo (long long)1e9

#define ll long long

#define setdp memset(dp,-1,sizeof(dp))

const ll mod = 1e9+7;

void _IOS(){ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin.sync_with_stdio(0);}

#define PI 3.14159265359

vector<pair<int,int>>v;

ll m,n;

char a[1009][1009];

ll dp[1009][1009];

ll solve(int i,int j)

{

   if(i<0||i>=n||j<0||j>=m||a[i][j]=='#')

        return 0;

    if(i==n-1&&j==m-1)

        return 1;

    if(dp[i][j]!=-1)

        return dp[i][j];

    ll ans=0;

    ans+=solve(i+1,j);

    ans+=solve(i,j+1);

    return dp[i][j]=ans%mod;

}

int main()

{

    //freopen("out.text","w",stdout);

    _IOS();

    memset(dp,-1,sizeof(dp));

    cin>>n>>m;

    for(int i=0;i<n;i++)

    {

        for(int j=0;j<m;j++)

        {

            cin>>a[i][j];

        }

    }

    cout<<solve(0,0);

}



//


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define ll long long int

ll mod  = 1000000000+7;

char g[1000+5][1005];

ll dp[1005][1005];

int main(){

int n, m;

cin >> n >> m;

for(int i=0; i<n; i++)

    for(int j=0; j<m; j++)

        cin >> g[i][j];



for(int i=0;i<n; i++) {

      if (g[i][0]=='#') break;

    dp[i][0] = 1;

}

for(int j=0; j<m; j++){

    if(g[0][j]=='#') break;

     dp[0][j] = 1;

}



for(int i=1; i<n; i++){

    for(int j=1; j<m; j++){

            if(g[i][j]=='#') continue;

        dp[i][j] = (dp[i-1][j]+dp[i][j-1]) %mod;

        //cout << i<<" "<<j <<" "<< dp[i][j] <<" ";

    }

    //cout << endl;

}

cout << dp[n-1][m-1];

return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define f(i,s,v) for(int i=(int)s;i<(int)v;++i)

#define rf(i,s,v) for(int i=(int)s-1;i>(int)v;--i)

#define pb push_back

#define all(v) ((v.begin()),(v.end()))

#define memset(c, value) memset(c, (int)value, sizeof(c))

using namespace std;

typedef long long ll;

const int oo = 1e9+5;

const ll MOD =1e9+7;

const double pi = acos(-1);

void fast(){

    ios_base :: sync_with_stdio(0);

    cin.tie(0);

    cout.tie(0);

}

int n, m;

bool valid (int r,int c){

    return (r < n && r >= 0 && c >= 0 && c < m);

}



int row[] = {0 , 1 , 0, -1};

int column[] = {1 , 0, -1, 0};



char a[1001][1001];

int dp[1001][1001];



int path(int r, int c){

    if(!valid(r, c) || a[r][c] == '#')

        return 0;

    if(r == n-1 && c == m-1)

        return 1;



    int &ret = dp[r][c];

    if(ret != -1) return ret;



    ret = 0;



    return ret = (ret + path(r+1, c)%MOD + path(r, c+1)%MOD)%MOD;

}



int main()

{

    fast();



    cin>>n>>m;

    f(i, 0, n)

    f(j, 0, m)

        cin>>a[i][j];

    memset(dp, -1);

    cout<<path(0,0)<<'\n';



    return 0;

}


// Optimized solution to the same problem (faster):
#include <iostream>

using namespace std;

int mod=1e9+7,dp[1011][1010];

char a[1011][1011];

int main(){

	int n,m;

	cin >> n >> m;

	for(int i=1;i<=n;i++){

		for(int j=1;j<=m;j++){

			cin >> a[i][j];

		}

	}

	dp[1][1]=1;

	for(int i=1;i<=n;i++){

		for(int j=1;j<=m;j++){

				if(i==1 && j==1 || a[i][j]=='#'){

					continue;

				}

				dp[i][j]=(dp[i-1][j]+dp[i][j-1])%mod;

		}

	}

	cout << dp[n][m];

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using ii = pair<int, int>;

using iii = pair<ii, int>;

#define vt vector

#define pb push_back

#define pf push_front

#define mp make_pair

#define fi first

#define se second

#define __lcm(a, b) a * b / __gcd(a, b)x

const int MOD = 1e9 + 7;

const int INF = 2e9;

const int N = 1e3 + 5;



int R, C;

int dp[N][N];

char grid[N][N];



int add(int x, int y) {

    return ((x % MOD) + (y % MOD)) % MOD;

}



bool inside(int r, int c) {

    return r >= 1 && r <= R && c >= 1 && c <= C;

}



int f(int r, int c) {

    if(grid[r][c] == '#') return 0;

    if(!inside(r, c)) return 0;

    if(r == R && c == C) return 1;

    int &sol = dp[r][c];

    if(sol != -1) return sol;

    return sol = add(f(r + 1, c), f(r, c + 1));

}



void solve() {

    cin >> R >> C;

    for(int i = 1; i <= R; i++) {

        for(int j = 1; j <= C; j++) {

            cin >> grid[i][j];

        }

    }

    memset(dp, -1, sizeof(dp));

    cout << f(1, 1) % MOD << "\n";

}



int main() {

 

    ios_base::sync_with_stdio(0);

    cin.tie(0); cout.tie(0);



    solve();

    

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



const int MAX_N = 1e5 + 5;

const int MAX_L = 20; // ~ Log N

const long long MOD = 1e9 + 7;

const long long INF = 1e9 + 7;



typedef long long ll;

typedef vector<int> vi;

typedef pair<int,int> ii;

typedef vector<ii> vii;

typedef vector<vi> vvi;



const int MAXH = 1010, MAXW = 1010;



char grid[MAXH][MAXW];

int dp[MAXH][MAXW];

bool visited[MAXH][MAXW];



int h, w;



ll solve(int x, int y){

	if(x >= h || y >= w) return 0;

	if(grid[x][y] == '#') return 0;

	if(visited[x][y]) return dp[x][y];

	if(x == h-1 && y == w - 1) return dp[x][y] = 1;

	

	visited[x][y] = true;

	return dp[x][y] = (solve(x+1,y) + solve(x,y+1))%MOD;

}



int main(){

	ios_base::sync_with_stdio(0);

    cin.tie(0); cout.tie(0);

    

    //freopen("input.txt", "r", stdin);

    //freopen("output.txt", "w", stdout);

	

	

	cin >> h >> w;

	for(int i = 0; i < h; i++){

		for(int j = 0; j < w; j++)

			cin >> grid[i][j];

	}

	ll ans = solve(0,0);

	cout << ans;

	

	return 0;

}


// Fastest known solution for this problem: