// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt")
#include<bits/stdc++.h>
 
using namespace std;
 
#define i64 long long
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()

int N, K;
char g[5][101];
double f[103][(1 << 3) + 1][303], fmask[(1 << 3) + 2];
pair<double, int> cost[103][103][(1 << 3) + 2][(1 << 3) + 2];
bool can[103][(1 << 3) + 1];
void Solve(void) {
  cin >> N >> K;
  for (int i = 1; i <= 3; i ++) {
    for (int j = 1; j <= N; j ++) {
      cin >> g[i][j];
    }
  }

  for (int mask = 0; mask < (1 << 3); mask ++) {
    int prev = -1;
    int minDist = 1e9;
    for (int b = 0; b < 3; b ++) {
      if (mask >> b & 1) {
        if (prev != -1) {
          minDist = min(minDist, b - prev);
        }
        prev = b;
      }
    }
    fmask[mask] = minDist;
  }
  for (int j = 0; j <= N; j ++) {
    for (int mask = 0; mask < (1 << 3); mask ++) {
      bool works = true;
      for (int b = 0; b < 3; b ++) {
        if (mask >> b & 1) {
          if (g[b + 1][j] == '#') {
            works = false;
          }
        }
      }
      can[j][mask] = works;
      // cout << j << " " << mask << " " << works << "\n";
      for (int k = 0; k <= K; k ++) {
        f[j][mask][k] = -1;
      } 
    }
  }

  for (int j = 0; j <= N; j ++) {
    for (int jj = j + 1; jj <= N; jj ++) {
      for (int mask = 0; mask < (1 << 3); mask ++) {
        for (int maskk = 0; maskk < (1 << 3); maskk ++) {
          bool works = (can[j][mask] & can[jj][maskk]);
          if (!works) {
            cost[j][jj][mask][maskk] = mp(-1.0, -1);
            continue;
          }
          double minDist = min(fmask[mask], fmask[maskk]);
          int cnt = 0;
          for (int bb = 0; bb < 3; bb ++) {
            if (maskk >> bb & 1) {
              cnt ++;
              for (int b = 0; b < 3; b ++) {
                if (mask >> b & 1) {
                  double d = (b - bb) * (b - bb) + (jj - j) * (jj - j);
                  minDist = min(minDist, sqrt(1.0 * d));
                }
              }
            }
          }
          cost[j][jj][mask][maskk] = mp(minDist, cnt);
        }
      }
    }
  }
  for (int jj = 1; jj <= N; jj ++) {
    for (int j = jj - 1; j >= 0; j --) {
      for (int mask = 0; mask < (1 << 3); mask ++) {
        for (int maskk = 0; maskk < (1 << 3); maskk ++) {
          auto [d, cnt] = cost[j][jj][mask][maskk];
          if (d == -1 || cnt <= 0) continue;
          f[jj][maskk][cnt] = max(f[jj][maskk][cnt], d);
          for (int k = 0; k <= K; k ++) {
            if (k >= cnt) {
              f[jj][maskk][k] = max(f[jj][maskk][k], min(f[j][mask][k - cnt], d));
            }
          }
        }
      }
    }
  }

  double ans = -1;
  for (int mask = 0; mask < (1 << 3); mask ++) {
    ans = max(ans, f[N][mask][K]);
  }
  if (N == K) {
    // Best case is 2
    ans = min(ans, 2.0);
  }
  cout << ans << "\n";
}
signed main() {
  ios_base::sync_with_stdio(false); cin.tie(0);
  cout << fixed << setprecision(10);
  int Tests = 1; // cin >> Tests; 
  while (Tests --) {
    Solve();    
  }
}