77_D. Domino Carpet_13664
...Mike the TV greets you again!

Tired of the monotonous furniture? Sick of gray routine? Dreaming about dizzying changes in your humble abode? We have something to offer you!

This domino carpet for only $99.99 will change your life! You can lay it on the floor, hang it on the wall or even on the ceiling! Among other things ...

Having watched the commercial, virus Hexadecimal also wanted to get a Domino Carpet and wanted badly to be photographed in front of it. But of course, a virus will never consent to buying a licensed Carpet! So she ordered a truck of dominoes and decided to make such a Carpet herself. 

The original Domino Carpet is a field of squares n × m in size. Each square is half of a domino, and can be rotated either vertically or horizontally, independently from its neighbors. Vertically rotated domino halves look like this: 

<image>

And horizontally rotated halves look like this: 

<image>

Notice, that some halves looks the same in both rotations, but other halves differ.

Dominoes bought by Hexadecimal are represented by uncuttable chips 1 × 2 in size, which can be laid either vertically or horizontally. If the chip is laid vertically, then both of it's halves should be laid vertically orientated; if the chip is laid horizontally, then both of it's halves should be laid horizontally.

The samples of valid and invalid dominoes laid vertically and horizontally are: 

<image>

Virus Hexadecimal assembles her own Domino Carpet so that the following conditions are satisfied:

  * each carpet square is covered by a domino chip, i.e. there are no empty squares; 
  * all domino chips lie entirely within the carpet and don't overlap with each other; 
  * if there is a horizontal domino chip with its left half in column j then there are no horizontal domino chips with their left halves in columns j - 1 or j + 1. 



Before starting to assemble her own Domino Carpet, the virus wants to know the number of ways to achieve the intended purpose modulo 109 + 7.

You can assume that the virus has an infinitely large number of dominoes of each type.

Input

The first line contains two integers n and m, separated by a space — the size of the Domino Carpet (1 ≤ n, m ≤ 250). Next 4n + 1 lines contain 4m + 1 symbols. 

Each square of the Domino Carpet, which is a domino half, is described by a 3 × 3 square. Symbol 'O' in this square indicates the presence of a point, symbol '.' — its absence. 

Each 3 × 3 square is delineated from adjacent squares by symbols '#' as shown in the examples. 

It is guaranteed that every box describes the correct half of a domino. 

In all pretests the Domino Carpets have the size of 2 × 2 and 4 × 4.

Output

Print a single number, the number of ways to assemble the Domino Carpet modulo 109 + 7, using only standard dominoes of size 1 × 2.

Examples

Input

3 4
#################
#O..#...#O.O#...#
#.O.#.O.#.O.#...#
#..O#...#O.O#...#
#################
#O.O#OOO#O.O#...#
#.O.#...#...#.O.#
#O.O#OOO#O.O#...#
#################
#O.O#...#O.O#...#
#...#...#...#.O.#
#O.O#...#O.O#...#
#################


Output

3

Input

2 2
#########
#O.O#O.O#
#.O.#...#
#O.O#O.O#
#########
#...#O.O#
#...#...#
#...#O.O#
#########


Output

2

Input

2 2
#########
#..O#O..#
#...#...#
#O..#..O#
#########
#O..#..O#
#...#...#
#..O#O..#
#########


Output

0

Note

A note to the first example: all correct ways to make Domino Carpet are represented below:

<image>

And this way is incorrect:

<image>
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
const int MOD = 1000000007;
int n, m;
vector<string> C;
vector<vector<char> > M;
vector<ll> DPh, DPv;
vector<bool> Hor;
char read_value(int x, int y) {
  int v = 0;
  char result = '_';
  for (int i = 4 * x + 1; i < 4 * x + 4; ++i) {
    for (int j = 4 * y + 1; j < 4 * y + 4; ++j) {
      if (C[i][j] == 'O') {
        v++;
      }
    }
  }
  if (v == 2 || v == 3) {
    result = (C[4 * x + 1][4 * y + 1] == '.') ? 'v' : 'h';
  } else if (v == 6) {
    result = (C[4 * x + 1][4 * y + 2] == '.') ? 'v' : 'h';
  }
  return result;
}
ll solv(int x, int y) {
  if (x > m - 2 || y > n) return 0;
  if (y == n) return 1;
  ll result = 0;
  if (DPv[y] > -1) {
    return DPv[y];
  }
  DPv[y] = 0;
  if (M[y][x] != 'v' && M[y][x + 1] != 'v') {
    DPv[y] += solv(x, y + 1);
  }
  if (y < n - 1 && M[y][x] != 'h' && M[y][x + 1] != 'h' && M[y + 1][x] != 'h' &&
      M[y + 1][x + 1] != 'h') {
    DPv[y] += solv(x, y + 2);
  }
  DPv[y] %= MOD;
  return DPv[y];
}
ll sol(int x) {
  if (x > m) return 0;
  if (x == m) return 1;
  ll result = 0;
  if (DPh[x] > -1) {
    return DPh[x];
  }
  DPh[x] = 0;
  if (n % 2 == 0 && !Hor[x]) {
    DPh[x] = sol(x + 1);
  }
  DPv.clear();
  DPv.resize(n, -1);
  ll s_2 = solv(x, 0);
  if (n % 2 == 0 && x < m - 1 && !Hor[x] && !Hor[x + 1]) {
    s_2 -= 1;
  }
  DPh[x] += s_2 * sol(x + 2);
  DPh[x] %= MOD;
  return DPh[x];
}
int main() {
  ios::sync_with_stdio(false);
  cout.precision(20);
  cin.tie(NULL);
  while (cin >> n) {
    cin >> m;
    C.resize(4 * n + 1);
    M.clear();
    M.resize(n, vector<char>(m, '_'));
    for (int i = 0; i < 4 * n + 1; ++i) {
      cin >> C[i];
    }
    Hor.clear();
    Hor.resize(m, false);
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < m; ++j) {
        M[i][j] = read_value(i, j);
        if (M[i][j] == 'h') {
          Hor[j] = true;
        }
      }
    }
    DPh.clear();
    DPh.resize(m, -1);
    cout << sol(0) << endl;
  }
  return 0;
}
