Polycarp owns a shop in the capital of Berland. Recently the criminal activity in the capital increased, so Polycarp is thinking about establishing some better security in the storehouse of his shop.

The storehouse can be represented as a matrix with n rows and m columns. Each element of the matrix is either . (an empty space) or x (a wall).

Polycarp wants to hire some guards (possibly zero) to watch for the storehouse. Each guard will be in some cell of matrix and will protect every cell to the right of his own cell and every cell to the bottom of his own cell, until the nearest wall. More formally, if the guard is standing in the cell (x0, y0), then he protects cell (x1, y1) if all these conditions are met:

  * (x1, y1) is an empty cell; 
  * either x0 = x1 and y0 ≤ y1, or x0 ≤ x1 and y0 = y1; 
  * there are no walls between cells (x0, y0) and (x1, y1). There can be a guard between these cells, guards can look through each other.



Guards can be placed only in empty cells (and can protect only empty cells). The plan of placing the guards is some set of cells where guards will be placed (of course, two plans are different if there exists at least one cell that is included in the first plan, but not included in the second plan, or vice versa). Polycarp calls a plan suitable if there is not more than one empty cell that is not protected.

Polycarp wants to know the number of suitable plans. Since it can be very large, you have to output it modulo 109 + 7.

Input

The first line contains two numbers n and m — the length and the width of the storehouse (1 ≤ n, m ≤ 250, 1 ≤ nm ≤ 250).

Then n lines follow, ith line contains a string consisting of m characters — ith row of the matrix representing the storehouse. Each character is either . or x.

Output

Output the number of suitable plans modulo 109 + 7.

Examples

Input

1 3
.x.


Output

3


Input

2 2
xx
xx


Output

1


Input

2 2
..
..


Output

10


Input

3 1
x
.
x


Output

2

Note

In the first example you have to put at least one guard, so there are three possible arrangements: one guard in the cell (1, 1), one guard in the cell (1, 3), and two guards in both these cells.
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100001;
const long long MOD = 1000000007;
const long long INF = 1e18;
long long add(long long a, long long b) { return (a + b) % MOD; }
long long sub(long long a, long long b) { return (a - b + MOD) % MOD; }
long long mul(long long a, long long b) { return (a * b) % MOD; }
long long ADD(long long &a, long long b) { return a = add(a, b); }
long long SUB(long long &a, long long b) { return a = sub(a, b); }
long long MUL(long long &a, long long b) { return a = mul(a, b); }
long long n, m;
vector<vector<int>> grid;
long long dp[1 << 15][2][2], temp[1 << 15][2][2];
int main(int argc, const char *argv[]) {
  ios_base::sync_with_stdio(0), cin.tie(0);
  cin >> n >> m;
  if (n <= m) {
    grid = vector<vector<int>>(n, vector<int>(m, 0));
    for (int i = (0); i < (n); i++)
      for (int j = (0); j < (m); j++) {
        char x;
        cin >> x;
        if (x == 'x') grid[i][j] = 1;
      }
  } else {
    grid = vector<vector<int>>(m, vector<int>(n, 0));
    for (int j = (0); j < (n); j++)
      for (int i = (0); i < (m); i++) {
        char x;
        cin >> x;
        if (x == 'x') grid[i][j] = 1;
      }
    swap(n, m);
  }
  for (int j = (0); j < (m); j++) {
    for (int i = (0); i < (n); i++) {
      if (!i && !j) {
        if (!grid[i][j]) {
          dp[1][1][0] = 1;
          dp[0][0][1] = 1;
        } else
          dp[0][0][0] = 1;
        continue;
      }
      if (grid[i][j]) {
        for (int mask = (0); mask < (1 << n); mask++)
          for (int k1 = (0); k1 < (2); k1++)
            for (int k2 = (0); k2 < (2); k2++)
              ADD(temp[mask & (~(1 << i))][0][k2], dp[mask][k1][k2]);
        for (int mask = (0); mask < (1 << n); mask++)
          for (int k1 = (0); k1 < (2); k1++)
            for (int k2 = (0); k2 < (2); k2++)
              dp[mask][k1][k2] = temp[mask][k1][k2], temp[mask][k1][k2] = 0;
        continue;
      }
      for (int mask = (0); mask < (1 << n); mask++)
        for (int k1 = (0); k1 < (2); k1++) {
          if (k1 || mask & (1 << i)) {
            ADD(temp[mask][k1][0], dp[mask][k1][0]);
            ADD(temp[mask][k1][1], dp[mask][k1][1]);
          } else
            ADD(temp[mask][k1][1], dp[mask][k1][0]);
        }
      for (int mask = (0); mask < (1 << n); mask++)
        for (int k1 = (0); k1 < (2); k1++)
          for (int k2 = (0); k2 < (2); k2++)
            ADD(temp[mask | (1 << i)][1][k2], dp[mask][k1][k2]);
      for (int mask = (0); mask < (1 << n); mask++)
        for (int k1 = (0); k1 < (2); k1++)
          for (int k2 = (0); k2 < (2); k2++)
            dp[mask][k1][k2] = temp[mask][k1][k2], temp[mask][k1][k2] = 0;
    }
    for (int mask = (0); mask < (1 << n); mask++)
      for (int k2 = (0); k2 < (2); k2++)
        ADD(dp[mask][0][k2], dp[mask][1][k2]), dp[mask][1][k2] = 0;
  }
  long long ans = 0;
  for (int mask = (0); mask < (1 << n); mask++)
    for (int k1 = (0); k1 < (2); k1++)
      for (int k2 = (0); k2 < (2); k2++) ADD(ans, dp[mask][k1][k2]);
  cout << ans << endl;
  return 0;
}
