#include <bits/stdc++.h>
 
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
 
mt19937 rng((int) chrono::steady_clock::now().time_since_epoch().count());
    
const int MOD = 1e9 + 7;
const int MAXN = 5e5 + 5;
const ll INF = 2e18;

const int maxn = 110;
const int inf = 1000000010;

int n, k;

int dp[maxn][maxn][maxn];
int maxDP[maxn][maxn][maxn][3];

string v[3];

bool possible()
{
    int cnt = 0;

    for(int i = 0 ; i < 3 ; i++)
        for(int j = 0 ; j < n ; j++)
            if( v[i][j] == '.' ) cnt++;

    return ( cnt >= k );
}

bool hasMinDist(int a, int b, int c, int d, int r)
{
    if( b == 0 || d == 0 )
        return true;

    int dx = a - c; dx *= dx;
    int dy = b - d; dy *= dy;

    return dx + dy >= r;
}

bool isValidState(int a, int b, int c, int r)
{
    if( a > 0 && v[0][a - 1] == '#' )
        return false;

    if( b > 0 && v[1][b - 1] == '#' )
        return false;

    if( c > 0 && v[2][c - 1] == '#' )
        return false;

    if( !hasMinDist( 0 , a , 1 , b , r ) )
        return false;

    if( !hasMinDist( 0 , a , 2 , c , r ) )
        return false;

    if( !hasMinDist( 1 , b , 2 , c , r ) )
        return false;

    return true;
}

int calculateMin(int alpha, int beta, int r)
{
    if( beta == 0 )
        return 0;

    r = max( r , alpha );
    return beta + ceil(sqrt(r - alpha));
}

bool test(int r)
{
    for(int a = n + 1 ; a >= 0 ; a--)
        for(int b = n + 1 ; b >= 0 ; b--)
            for(int c = n + 1 ; c >= 0 ; c--)
                maxDP[a][b][c][0] = maxDP[a][b][c][1] = maxDP[a][b][c][2] = -inf;

    for(int a = n ; a >= 0 ; a--)
    {
        for(int b = n ; b >= 0 ; b--)
        {
            for(int c = n ; c >= 0 ; c--)
            {
                int& ans = dp[a][b][c];
                ans = -inf;

                if( isValidState( a , b , c , r ) )
                {
                    ans = 0;

                    int minA = max( {calculateMin(0,a,r), calculateMin(1,b,r), calculateMin(4,c,r)} );
                    minA = max( minA , 1 );

                    if( minA <= n )
                        ans = max( ans , maxDP[minA][b][c][0] + 1 );

                    int minB = max( {calculateMin(1,a,r), calculateMin(0,b,r), calculateMin(1,c,r)} );
                    minB = max( minB , 1 );

                    if( minB <= n )
                        ans = max( ans , maxDP[a][minB][c][1] + 1 );

                    int minC = max( {calculateMin(4,a,r), calculateMin(1,b,r), calculateMin(0,c,r)} );
                    minC = max( minC , 1 );

                    if( minC <= n )
                        ans = max( ans , maxDP[a][b][minC][2] + 1 );
                }

                maxDP[a][b][c][0] = max( maxDP[a + 1][b][c][0] , ans );
                maxDP[a][b][c][1] = max( maxDP[a][b + 1][c][1] , ans );
                maxDP[a][b][c][2] = max( maxDP[a][b][c + 1][2] , ans );
            }
        }
    }

    return dp[0][0][0] >= k;
}

int bs()
{
    int l = 1, r = n*n + 100;

    while( l < r )
    {
        int m = ( l + r )/2;
        if( l == r - 1 ) m = r;

        if( test(m) ) 
            l = m;
        else
            r = m - 1;
    }

    return l;
}

int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n >> k;

    for(int i = 0 ; i < 3 ; i++)
        cin >> v[i];

    if( !possible() )
    {
        cout << -1 << endl;
        return 0;
    }

    cout << fixed << setprecision(12);
    cout << sqrt(bs()) << endl;
    
    return 0;
}