#include <cstdio>

 #include <iostream>

 #include <algorithm>

 #include <cstring>

 using namespace std;

 typedef long long LL;

 const int MAXN = ;

 const int SIZEH = ;

 const int MAXH = ;

 struct hash_map {

     int head[SIZEH], size;

     int state[MAXH], next[MAXH];

     LL val[MAXH];

     void init() {

         memset(head, -, sizeof(head));

         size = ;

     }

     void insert(int st, LL sv) {

         int h = st % SIZEH;

         for(int p = head[h]; ~p; p = next[p]) {

             if(state[p] == st) {

                 val[p] += sv;

                 return ;

             }

         }

         state[size] = st; val[size] = sv; next[size] = head[h]; head[h] = size++;

     }

 } hashmap[];

 hash_map *cur, *last;

 int acc[] = {, -, , };

 char mat[MAXN][MAXN];

 int n, m, en, em;

 int getB(int state, int i) {

     return (state >> (i << )) & ;

 }

 void setB(int &state, int i, int val) {

     state = (state & ~( << (i << ))) | (val << (i << ));

 }

 int getLB(int state, int i) {

     int ret = i, cnt = ;

     while(cnt) {

         --ret;

         cnt += acc[getB(state, ret)];

     }

     return ret;

 }

 int getRB(int state, int i) {

     int ret = i, cnt = -;

     while(cnt) {

         ++ret;

         cnt += acc[getB(state, ret)];

     }

     return ret;

 }

 void update(int x, int y, int state, LL tv) {

     int left = getB(state, y);

     int up = getB(state, y + );

     if(mat[x][y] == '#') {

         if(left ==  && up == ) cur->insert(state, tv);

         return ;

     }

     if(left ==  && up == ) {

         if(x == n -  || y == m - ) return ;

         int newState = state;

         setB(newState, y, );

         setB(newState, y + , );

         cur->insert(newState, tv);

     } else if(left ==  || up == ) {

         if(x < n - ) {

             int newState = state;

             setB(newState, y, up + left);

             setB(newState, y + , );

             cur->insert(newState, tv);

         }

         if(y < m - ) {

             int newState = state;

             setB(newState, y, );

             setB(newState, y + , up + left);

             cur->insert(newState, tv);

         }

     } else {

         int newState = state;

         setB(newState, y, );

         setB(newState, y + , );

         if(left ==  && up == ) setB(newState, getRB(state, y + ), );

         if(left ==  && up ==  && !(x == en && y == em)) return ;

         if(left ==  && up == ) setB(newState, getLB(state, y), );

         cur->insert(newState, tv);

     }

 }

 void findend() {

     for(en = n - ; en >= ; --en)

         for(em = m - ; em >= ; --em) if(mat[en][em] != '#') return ;

 }

 LL solve() {

     findend();

     cur = hashmap, last = hashmap + ;

     last->init();

     last->insert(, );

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

         int sz = last->size;

         for(int k = ; k < sz; ++k) last->state[k] <<= ;

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

             cur->init();

             sz = last->size;

             for(int k = ; k < sz; ++k)

                 update(i, j, last->state[k], last->val[k]);

             swap(cur, last);

         }

     }

     for(int k = ; k < last->size; ++k)

         if(last->state[k] == ) return last->val[k];

     return ;

 }

 int main() {

     while(scanf("%d%d", &n, &m) != EOF) {

         if(n ==  && m == ) break;

         memset(mat, , sizeof(mat));

         for(int i = ; i < n; ++i) scanf("%s", mat[i]);

         for(int i = ; i < m - ; ++i) mat[n][i] = '#';

         n += ;

         cout<<solve()<<endl;

     }

 }