#include<bits/stdc++.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <vector>
using namespace std;
typedef int ll;
typedef vector<int> vi;
typedef pair<ll,ll> pll;
typedef pair<int, int> pii;
typedef vector<pii> vii;
typedef vector<vector<int> > vvi;
typedef vector<string> vs;
#define fi first
#define se second
#define rep(i,l,r) for(int i=l;i<=r;++i)
#define per(i,r,l) for(int i=r;i>=l;--i)
#define rep0(i,l,r) for(int i=l;i<r;++i)
#define forn(i,n) for(int i=0;i<n;++i)
#define all(a) (a).begin(), (a).end()
#define allr(a) (a).rbegin(), (a).rend()
#define foreach(a) for(auto it = a.begin(); it != a.end(); it++)
#define mem(a,b) memset(a, (b), sizeof(a))
//mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
//uniform_int_distribution<ll> rnd(0,LLONG_MAX);
template<typename T>
inline T cei(T x, T y) {
	T t = (x+y-1)/y;
	return t;
}

template<typename T>
inline T power(T base, T powerRaised) {
	if (powerRaised != 0) return (base*power(base, powerRaised-1));
	else return 1;
}

template<typename T>
inline T gcd(T a, T b) {
	while(b) {
		b^=a^=b^=a%=b;
	}
	return a;
}

template<typename T>
inline T lcm(T x, T y ) {
	return x*y/gcd(x,y);
}
template<typename T>
inline T findLessPower(T base, T n) {
	if(n==1) {
		return 0;
	}
	T temp = log(n)/log(base);
	if(power(base, temp) == n) {
		return temp-1;
	} else {
		return temp;
	}
}
const ll mod1=1e9+7;
const ll mod2=1e9+9;
const ll INF=1e9+5;
const ll maxN=2e5+5;
const ll MAXLEN=1e6+5;
ll gcdl(ll a,ll b) {
	if(a==0||b==0) {
		return abs(a+b);
	}
	return gcdl(b%a,a);
}
//ll lcml(ll a,ll b) {
//	if(a>=INF||b>=INF) {
//		return INF;
//	}
//	ll ans=a*b/gcdl(a,b);
//	if(ans>=INF) {
//		return INF;
//	}
//	return ans;
//}
ll mo(ll a,ll b,ll mod) {
	if(b==0) {
		return 1ll;
	}
	ll vmod;
	vmod=mo(a,b/2,mod);
	vmod=(vmod*vmod)%mod;
	if(b%2==0) {
		return vmod;
	}
	return (vmod*a)%mod;
}
ll segtree[4*maxN];
ll lazy[4*maxN];
void push(ll v,ll l,ll r,ll mid){
	if(lazy[v]!=0){
		segtree[2*v]+=(mid-l+1)*lazy[v];
		segtree[2*v+1]+=(r-mid)*lazy[v];
		lazy[2*v]+=lazy[v];
		lazy[2*v+1]+=lazy[v];
		lazy[v]=0;
	}
}
void update(ll number,ll tl,ll tr,ll pos, ll val){
	if(tl==tr){
		segtree[number]+=val;
		return;
	}
	ll mid=(tl+tr)/2;
	if(pos<=mid){
	    update(2*number,tl,mid,pos,val);
	}
	else{
	    update(2*number+1,mid+1,tr,pos,val);
	}
	segtree[number]=segtree[2*number]+segtree[2*number+1];	
}
void build(ll number, ll a[],ll tl,ll tr){
	lazy[number]=0;
	if(tl==tr){
		segtree[number]=a[tl];
		return;
	}
	ll mid=(tl+tr)/2;
	build(2*number,a,tl,mid);
	build(2*number+1,a,mid+1,tr);
	segtree[number]=max(segtree[number*2],segtree[number*2+1]);
}
ll query(ll number,ll tl,ll tr,ll l ,ll r){
    if(l>r){
    	return -1;
    }
	if(l<=tl&&r>=tr){
	    return segtree[number];
	}
	ll mid=(tl+tr)/2;
	return max(query(2*number,tl,mid,l,min(r,mid)),query(2*number+1,mid+1,tr,max(mid+1,l),r));
}
ll mu2(ll x){
	return x*x;
}
void solve(ll tc) {
	ll i,j,n,m,k,prev,j1;
	cin >> n >> m;
	string s[3];
	cin >> s[0] >> s[1] >> s[2];
	ll num=0;
	for(i=0;i<3;i++){
		for(j=0;j<n;j++){
			if(s[i][j]=='.'){
				num++;
			}
		}
	}
	if(num<m){
		cout << -1;
		return;
	}
	ll l,r,mid;
	l=1;
	r=n*n+6;
	ll dp[n+1][8],mxdp[n+1];
	while(l<r){
		mid=(l+r+1)/2;
		//cout << l << " " << r << "\n";
		ll sq=sqrt(mid-1);
		ll sq1=sq-1;
		for(j=0;j<8;j++){
			dp[0][j]=-INF;
		}
		mxdp[0]=0;
		dp[0][0]=0;
		for(i=1;i<=n;i++){
			dp[i][0]=mxdp[i-1];
			mxdp[i]=dp[i][0];
			for(j=1;j<8;j++){
				dp[i][j]=-INF;
				vector<ll> onesj;
				bool able=true;
				for(k=0;k<3;k++){
					if((j>>k)%2==1){
						onesj.push_back(k);
						if(s[k].size()<i||s[k][i-1]=='#'){
							able=false;
						}
					}	
				}

				for(k=0;k+1<onesj.size();k++){
	
					if((onesj[k+1]-onesj[k])*(onesj[k+1]-onesj[k])<mid){
						able=false;
					}
				}
				if(!able){
					dp[i][j]=-INF;
					continue;
				}
				dp[i][j]=(ll)onesj.size();
				if(i>=sq+1){
					dp[i][j]=max(dp[i][j],mxdp[i-sq-1]+(ll)onesj.size());
				}
				
				if(i>sq&&sq>0){
					for(j1=1;j1<8;j1++){
						vector<ll> onesj1;
						for(k=0;k<3;k++){
							if((j1>>k)%2==1){
								onesj1.push_back(k);
							}	
						}
						able=true;
						
						for(auto k:onesj){
							for(auto k1:onesj1){
								if(mu2(k-k1)+mu2(sq)<mid){
									able=false;
								}
							}
						}
						if(able&&dp[i-sq][j1]>=0){
							dp[i][j]=max(dp[i][j],dp[i-sq][j1]+(ll)onesj.size());
						}
					}
				}
				
				if(i>sq1&&sq1>0){
					for(j1=1;j1<8;j1++){
						vector<ll> onesj1;
						for(k=0;k<3;k++){
							if((j1>>k)%2==1){
								onesj1.push_back(k);
							}	
						}
						able=true;
						
						for(auto k:onesj){
							for(auto k1:onesj1){
								if(mu2(k-k1)+mu2(sq1)<mid){
									able=false;
								}
							}
						}
						if(able&&dp[i-sq1][j1]>=0){
							dp[i][j]=max(dp[i][j],dp[i-sq1][j1]+(ll)onesj.size());
						}
					}
				}
				
				mxdp[i]=max(mxdp[i],dp[i][j]);
			}
			//cout << mxdp[i] << " ";
		}
		//cout <<  "\n";
		if(mxdp[n]>=m){
			l=mid;
		}
		else{
			r=mid-1;
		}
	}
	cout << fixed << setprecision(9) << sqrt(l);
}


int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	ll c,i,j;
	c=1;
	//cin >> c;
	for(i=1;i<=c;i++){
		solve(i);
	}
}