stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.063393789513474x):
#include <bits/stdc++.h>

using namespace std;

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



const long long MOD = 1e9 + 7;

const int MAXH = 1000 + 5;



struct Pos {

    int x;

    int y;

};



int h, w;

long long dp[MAXH][MAXH];

char board[MAXH][MAXH];



void calc(int x, int y) {

    if (x < 1 || y > w) {

        return;

    }

    if (x - 1 >= 1 && board[x - 1][y] != '#') {

        dp[x][y] = (dp[x][y] + dp[x - 1][y]) % MOD;

    }

    if (y - 1 >= 1 && board[x][y - 1] != '#') {

        dp[x][y] = (dp[x][y] + dp[x][y - 1]) % MOD;

    }

    calc(x - 1, y + 1);

}



void solve(int x, int y) {

    if (y > w) {

        return;

    }

    if (x == h) {

        calc(x, y);

        solve(x, y + 1);

    } else {

        calc(x, y);

        solve(x + 1, y);

    }

}



int main() {

    IOS



    cin >> h >> w;

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

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

            cin >> board[i][j];

        }

    }



    dp[1][1] = 1;

    solve(1, 1);



    cout << dp[h][w] << '\n';

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 9.306354782521343x):
#include <bits/stdc++.h>

using namespace std;

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



const long long MOD = 1e9 + 7;

const int MAXH = 1000 + 5;



struct Pos {

    int x;

    int y;

};



int h, w;

long long dp[MAXH][MAXH];

char board[MAXH][MAXH];



void calc(int x, int y) {

    if (x < 1 || y > w) {

        return;

    }

    if (x - 1 >= 1 && board[x - 1][y] != '#') {

        dp[x][y] = (dp[x][y] + dp[x - 1][y]) % MOD;

    }

    if (y - 1 >= 1 && board[x][y - 1] != '#') {

        dp[x][y] = (dp[x][y] + dp[x][y - 1]) % MOD;

    }

    calc(x - 1, y + 1);

}



void solve(int x, int y) {

    if (y > w) {

        return;

    }

    if (x == h) {

        calc(x, y);

        solve(x, y + 1);

    } else {

        calc(x, y);

        solve(x + 1, y);

    }

}



int main() {

    IOS



    cin >> h >> w;

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

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

            cin >> board[i][j];

        }

    }



    dp[1][1] = 1;

    solve(1, 1);



    cout << dp[h][w] << '\n';

}
// Slower C++ solution:
#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();

	}

}  
















// Faster C++ solution for the same problem (measured speedup: 9.63031583419435x):
#include <bits/stdc++.h>

using namespace std;

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



const long long MOD = 1e9 + 7;

const int MAXH = 1000 + 5;



struct Pos {

    int x;

    int y;

};



int h, w;

long long dp[MAXH][MAXH];

char board[MAXH][MAXH];



void calc(int x, int y) {

    if (x < 1 || y > w) {

        return;

    }

    if (x - 1 >= 1 && board[x - 1][y] != '#') {

        dp[x][y] = (dp[x][y] + dp[x - 1][y]) % MOD;

    }

    if (y - 1 >= 1 && board[x][y - 1] != '#') {

        dp[x][y] = (dp[x][y] + dp[x][y - 1]) % MOD;

    }

    calc(x - 1, y + 1);

}



void solve(int x, int y) {

    if (y > w) {

        return;

    }

    if (x == h) {

        calc(x, y);

        solve(x, y + 1);

    } else {

        calc(x, y);

        solve(x + 1, y);

    }

}



int main() {

    IOS



    cin >> h >> w;

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

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

            cin >> board[i][j];

        }

    }



    dp[1][1] = 1;

    solve(1, 1);



    cout << dp[h][w] << '\n';

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 5.049434354004495x):
#include <bits/stdc++.h>

using namespace std;

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



const long long MOD = 1e9 + 7;

const int MAXH = 1000 + 5;



struct Pos {

    int x;

    int y;

};



int h, w;

long long dp[MAXH][MAXH];

char board[MAXH][MAXH];



void calc(int x, int y) {

    if (x < 1 || y > w) {

        return;

    }

    if (x - 1 >= 1 && board[x - 1][y] != '#') {

        dp[x][y] = (dp[x][y] + dp[x - 1][y]) % MOD;

    }

    if (y - 1 >= 1 && board[x][y - 1] != '#') {

        dp[x][y] = (dp[x][y] + dp[x][y - 1]) % MOD;

    }

    calc(x - 1, y + 1);

}



void solve(int x, int y) {

    if (y > w) {

        return;

    }

    if (x == h) {

        calc(x, y);

        solve(x, y + 1);

    } else {

        calc(x, y);

        solve(x + 1, y);

    }

}



int main() {

    IOS



    cin >> h >> w;

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

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

            cin >> board[i][j];

        }

    }



    dp[1][1] = 1;

    solve(1, 1);



    cout << dp[h][w] << '\n';

}
// Slower C++ solution:
#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);

}



//


// Faster C++ solution for the same problem (measured speedup: 9.445063661393212x):
#include <bits/stdc++.h>

using namespace std;

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



const long long MOD = 1e9 + 7;

const int MAXH = 1000 + 5;



struct Pos {

    int x;

    int y;

};



int h, w;

long long dp[MAXH][MAXH];

char board[MAXH][MAXH];



void calc(int x, int y) {

    if (x < 1 || y > w) {

        return;

    }

    if (x - 1 >= 1 && board[x - 1][y] != '#') {

        dp[x][y] = (dp[x][y] + dp[x - 1][y]) % MOD;

    }

    if (y - 1 >= 1 && board[x][y - 1] != '#') {

        dp[x][y] = (dp[x][y] + dp[x][y - 1]) % MOD;

    }

    calc(x - 1, y + 1);

}



void solve(int x, int y) {

    if (y > w) {

        return;

    }

    if (x == h) {

        calc(x, y);

        solve(x, y + 1);

    } else {

        calc(x, y);

        solve(x + 1, y);

    }

}



int main() {

    IOS



    cin >> h >> w;

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

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

            cin >> board[i][j];

        }

    }



    dp[1][1] = 1;

    solve(1, 1);



    cout << dp[h][w] << '\n';

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 5.043128998025622x):
#include <bits/stdc++.h>

using namespace std;

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



const long long MOD = 1e9 + 7;

const int MAXH = 1000 + 5;



struct Pos {

    int x;

    int y;

};



int h, w;

long long dp[MAXH][MAXH];

char board[MAXH][MAXH];



void calc(int x, int y) {

    if (x < 1 || y > w) {

        return;

    }

    if (x - 1 >= 1 && board[x - 1][y] != '#') {

        dp[x][y] = (dp[x][y] + dp[x - 1][y]) % MOD;

    }

    if (y - 1 >= 1 && board[x][y - 1] != '#') {

        dp[x][y] = (dp[x][y] + dp[x][y - 1]) % MOD;

    }

    calc(x - 1, y + 1);

}



void solve(int x, int y) {

    if (y > w) {

        return;

    }

    if (x == h) {

        calc(x, y);

        solve(x, y + 1);

    } else {

        calc(x, y);

        solve(x + 1, y);

    }

}



int main() {

    IOS



    cin >> h >> w;

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

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

            cin >> board[i][j];

        }

    }



    dp[1][1] = 1;

    solve(1, 1);



    cout << dp[h][w] << '\n';

}
// Slower C++ solution:
#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();

    

}

// Faster C++ solution for the same problem (measured speedup: 5.0760840982989395x):
#include <bits/stdc++.h>

using namespace std;

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



const long long MOD = 1e9 + 7;

const int MAXH = 1000 + 5;



struct Pos {

    int x;

    int y;

};



int h, w;

long long dp[MAXH][MAXH];

char board[MAXH][MAXH];



void calc(int x, int y) {

    if (x < 1 || y > w) {

        return;

    }

    if (x - 1 >= 1 && board[x - 1][y] != '#') {

        dp[x][y] = (dp[x][y] + dp[x - 1][y]) % MOD;

    }

    if (y - 1 >= 1 && board[x][y - 1] != '#') {

        dp[x][y] = (dp[x][y] + dp[x][y - 1]) % MOD;

    }

    calc(x - 1, y + 1);

}



void solve(int x, int y) {

    if (y > w) {

        return;

    }

    if (x == h) {

        calc(x, y);

        solve(x, y + 1);

    } else {

        calc(x, y);

        solve(x + 1, y);

    }

}



int main() {

    IOS



    cin >> h >> w;

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

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

            cin >> board[i][j];

        }

    }



    dp[1][1] = 1;

    solve(1, 1);



    cout << dp[h][w] << '\n';

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.073232767437471x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 9.324212892842072x):
#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;

}
// Slower C++ solution:
#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();

	}

}  
















// Faster C++ solution for the same problem (measured speedup: 9.64902906662948x):
#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;

}