#include <iostream>
#include <vector>
#include <bitset>
#include <stdio.h>

using namespace std;

ostream& operator<< ( ostream& os, const vector<uint32_t>& v )
{
  for( auto it = v.begin(); it != v.end(); it++ )
  {
    os << *it << "\n";
  }
  return os;
}

inline bitset<15> make_pattern()
{
  char field;
  bitset<15> pattern;

  for( uint32_t offset = 0; offset < 3; offset++ )
  {
    cin >> field;
    if( field == 'x' ) pattern.set(offset);

    cin >> field;
    if( field == 'x' ) pattern.set(offset + 5);

    cin >> field;
    if( field == 'x' ) pattern.set(offset + 10);
  }
  return pattern;
}

int main()
{
  uint32_t n, m, p;
  cin >> n;
  cin >> p;
  cin >> m;

  vector<bool> forbidden_patterns( 33000 );

  for( uint32_t i = 0; i < p; i++ )
  {
    auto pattern = make_pattern();
    forbidden_patterns[pattern.to_ulong()] = true;  // true := forbidden; false := allowed.
    forbidden_patterns[(pattern << 1).to_ulong()] = true;
    forbidden_patterns[(pattern << 2).to_ulong()] = true;
    //cout << forbidden_patterns[(pattern<<3).to_ulong()];
    //cout << pattern.to_ulong();
  }

  for( uint32_t i = 0; i< 33000; i++ ) //checking the contents of the forbidden_patterns vector
  {
    bitset<15> bs = i;
    if(forbidden_patterns[i] == true)
      cout << bs << "\n";
  }
  cout << "\n\n";

  //bitmasks for setting 2 rows of a 3 column pattern to 0;
  bitset<15> bottom_rows_reset_mask;
  bottom_rows_reset_mask.set(3); bottom_rows_reset_mask.set(8); bottom_rows_reset_mask.set(13);
  bottom_rows_reset_mask.set(4); bottom_rows_reset_mask.set(9); bottom_rows_reset_mask.set(14);
  bottom_rows_reset_mask = ~bottom_rows_reset_mask;

  bitset<15> top_rows_reset_mask;
  top_rows_reset_mask.set(0); top_rows_reset_mask.set(5); top_rows_reset_mask.set(10);
  top_rows_reset_mask.set(1); top_rows_reset_mask.set(6); top_rows_reset_mask.set(11);
  top_rows_reset_mask = ~top_rows_reset_mask;

  bitset<15> top_and_bottom_reset_mask;
  top_and_bottom_reset_mask.set(0); top_and_bottom_reset_mask.set(5); top_and_bottom_reset_mask.set(10);
  top_and_bottom_reset_mask.set(4); top_and_bottom_reset_mask.set(9); top_and_bottom_reset_mask.set(14);
  top_and_bottom_reset_mask = ~top_and_bottom_reset_mask;

  vector<uint32_t> left( 1024, 1 );
  vector<uint32_t> right( 1024, 0 );

  for( uint32_t column = 3; column <= n; column++ )
  {
    for( uint32_t first_2_columns = 0; first_2_columns < 1024; first_2_columns++ )
    {
      if( left[first_2_columns] == 0 ) continue;
      for( uint32_t third_column = 0; third_column < 32; third_column++ )
      {
        bitset<15> t_patt = (first_2_columns | third_column << 10) & top_and_bottom_reset_mask.to_ulong();
        //cout << t_patt << "\n"; //getchar();
        if( forbidden_patterns[t_patt.to_ulong()] == true )
        {
          //cout << t_patt << "\n"; getchar();
          continue;
        }

        t_patt = (first_2_columns | third_column << 10) & bottom_rows_reset_mask.to_ulong();
        //cout << t_patt << "\n"; //getchar();
        if( forbidden_patterns[t_patt.to_ulong()] == true )
        {
          //cout << t_patt << "\n"; getchar();
          continue;
        }

        t_patt = (first_2_columns | third_column << 10) & top_rows_reset_mask.to_ulong();
        //cout << t_patt << "\n"; //getchar();
        if( forbidden_patterns[t_patt.to_ulong()] == true )
        {
          //cout << t_patt << "\n"; getchar();
          continue;
        }

        t_patt = first_2_columns | third_column << 10;
        //cout << t_patt << "\n";
        auto next_2_column_pattern = (t_patt >> 5).to_ulong();
        //t_patt = next_2_column_pattern; cout << t_patt << "\n"; getchar();
        right[next_2_column_pattern] = (right[next_2_column_pattern] + left[first_2_columns]) % m;
      }
    }
    left.swap(right);
    right.assign(1024, 0u);
  }
  uint32_t sum = 0;
  for( int i = 0; i < 1024; i++ )
    sum = (sum + left[i]) % m;

  cout << sum;
}