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

using namespace std;

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> top_forbidden_patterns( 32768 ); // top_forbidden patterns can only be compared to 3 column patterns that have the top 2 rows zeroed.
  vector<bool> mid_forbidden_patterns( 32768 ); // mid_forbidden patterns can only be compared to 3 column patterns that have the top and bottom row zeroed.
  vector<bool> bottom_forbidden_patterns( 32768 ); // bottom_forbidden patterns can only be compared to 3 column patterns that have the bottom 2 rows zeroed.

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

  //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();
        if( mid_forbidden_patterns[t_patt.to_ulong()] == true )
          continue;

        t_patt = (first_2_columns | third_column << 10) & bottom_rows_reset_mask.to_ulong();
        if( bottom_forbidden_patterns[t_patt.to_ulong()] == true )
          continue;

        t_patt = (first_2_columns | third_column << 10) & top_rows_reset_mask.to_ulong();
        if( top_forbidden_patterns[t_patt.to_ulong()] == true )
          continue;

        t_patt = first_2_columns | third_column << 10;
        auto next_2_column_pattern = (t_patt >> 5).to_ulong();
        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( auto el : left )
    sum = (sum + el) % m;

  cout << sum;
  return 0;
}