#include <bits/stdc++.h>
using namespace std;

const double pi  = 2 * acos(0.0);
const double eps = 1e-8;

#define REP(i,a,b) for(int i=(a); i<(b);++i)
#define rep(i,n) REP(i,0,n)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

int dx[9] = {0, 0, 1, 0, -1, 1, -1, 1, -1};
int dy[9] = {0, 1, 0, -1, 0, 1, -1, -1, 1};

struct Block {
  char _b[2][2][2];
  char b[2][2][2];
  int h;

  Block() {
    rep(i, 2) rep(j, 2) rep(k, 2) _b[i][j][k] = b[i][j][k] = '.';
  }

  bool shift(int dx, int dy) {
    bool cant_shift;

    if (dx == -1) {
      cant_shift = false;
      rep(i, 2) {
        cant_shift = cant_shift || _b[i][0][0] == '#';
        cant_shift = cant_shift || _b[i][1][0] == '#';
      }
      if (cant_shift) return false;
    }

    if (dx == 1) {
      cant_shift = false;
      rep(i, 2) {
        cant_shift = cant_shift || _b[i][0][1] == '#';
        cant_shift = cant_shift || _b[i][1][1] == '#';
      }
      if (cant_shift) return false;
    }

    if (dy == -1) {
      cant_shift = false;
      rep(i, 2) {
        cant_shift = cant_shift || _b[i][0][0] == '#';
        cant_shift = cant_shift || _b[i][0][1] == '#';
      }
      if (cant_shift) return false;
    }

    if (dy == 1) {
      cant_shift = false;
      rep(i, 2) {
        cant_shift = cant_shift || _b[i][1][0] == '#';
        cant_shift = cant_shift || _b[i][1][1] == '#';
      }
      if (cant_shift) return false;
    }

    rep(i, 2) rep(j, 2) rep(k, 2) {
      b[i][j][k] = '.';
    }

    rep(i, 2) rep(j, 2) rep(k, 2) {
      if (_b[i][j][k] == '.') continue;
      b[i][j+dy][k+dx] = _b[i][j][k];
    }

    return true;
  }
};

bool collided(int h, char a[18][2][2], char b[2][2][2]) {
  rep(d, 2) rep(i, 2) rep(j ,2) {
    if (a[h+d][i][j] == '#' && a[h+d][i][j] == b[d][i][j]) return true;
  }
  return false;
}

void dump_tower(char tower[18][2][2]) {
  for (int i = 17; i >= 0; i--) {
    cout << tower[i][0][0]<< tower[i][0][1] << tower[i][1][0] << tower[i][1][1] << endl;
  }
}

int simulation(int block_no, char tower[18][2][2], vector<Block> &blocks) {
  int h = 16;
  bool cl;

  while (h >= 0) {
    cl = collided(h, tower, blocks[block_no].b);
    if (!cl && h != 0) {
      h--;
      continue;
    }

    if (cl) h++;

    rep(i, 2) rep(j, 2) rep(k, 2) {
      if (blocks[block_no].b[i][j][k] == '.') continue;
      tower[h+i][j][k] = blocks[block_no].b[i][j][k];
    }

    break;
  }

  int erased = 0;

  for (int i = 15; i >= 0; --i) {
    bool filled = true;
    rep(j, 2) rep(k, 2) {
      filled = filled && tower[i][j][k] == '#';
    }

    if (!filled) continue;

    erased++;

    REP(j, i, 16) rep(k, 2) rep(l, 2) {
      tower[j][k][l] = tower[j+1][k][l];
    }
  }

  return erased;
}

int solve(int block_no, char tower[18][2][2], vector<Block> &blocks) {
  if (block_no >= blocks.size()) return 0;

  char new_tower[18][2][2];
  bool can_shift;
  int max_erased = 0;

  rep (i, 9) {
    can_shift = blocks[block_no].shift(dx[i], dy[i]);
    if (!can_shift) continue;

    rep(j, 18) rep(k, 2) rep(l, 2) new_tower[j][k][l] = tower[j][k][l];
    int erased = simulation(block_no, new_tower, blocks);
    erased += solve(block_no + 1, new_tower, blocks);

    max_erased = max(max_erased, erased);
  }

  return max_erased;
}

int main(void) {
  ios_base::sync_with_stdio(false); cin.tie(0);
  int H, N;
  vector<Block> blocks;

  while (cin >> H >> N, H && N) {
    blocks.clear();
    blocks.resize(N);

    char tower[18][2][2];
    rep(i, 18) rep(j, 2) rep(k, 2) tower[i][j][k] = '.';

    rep(i, H) {
      cin >> tower[i][0][0] >> tower[i][0][1] >> tower[i][1][0] >> tower[i][1][1];
    }

    rep(i, N) {
      rep(j, 2) rep(k, 2) rep(l, 2) cin >> blocks[i]._b[j][k][l];

      bool should_drop = true;
      rep(j, 2) rep(k, 2) should_drop = should_drop && blocks[i]._b[0][j][k] == '.';
      if (should_drop) {
        rep(j, 2) rep(k, 2) {
          blocks[i]._b[0][j][k] = blocks[i]._b[1][j][k];
          blocks[i]._b[1][j][k] = '.';
        }
      }
    }

    cout << solve(0, tower, blocks) << endl;
  }
  return 0; 
}

Measured memory_bytes: 3092