/*
TASK:expres
LANG:C++
*/
#include <iostream>

using namespace std;
const int D[ 10 ][ 10 ] = {
{0, 7, 3, 3, 5, 3, 2, 5, 1, 2 },
{7, 0, 8, 6, 4, 8, 9, 2, 8, 7 },
{3, 8, 0, 2, 6, 4, 3, 6, 2, 3 },
{3, 6, 2, 0, 4, 2, 3, 4, 2, 1 },
{5, 4, 6, 4, 0, 4, 5, 4, 4, 3 },
{3, 8, 4, 2, 4, 0, 1, 6, 2, 1 },
{2, 9, 3, 3, 5, 1, 0, 7, 1, 2	},
{5, 2, 6, 4, 4, 6, 7, 0, 6, 5 },
{1, 8, 2, 2, 4, 2, 1, 6, 0, 1 },
{2, 7, 3, 1, 3, 1, 2, 5, 1, 0 }  };
int DS[ 20 ][ 20 ];
int B[ 10 ] = { 12, 5, 11, 11, 9, 11, 12, 7, 13, 12 };


const char NUMS[ 10 ][ 5 ][ 3 ] = {
{
{1,1,1},
{1,0,1},
{1,0,1},
{1,0,1},
{1,1,1}
},
{
{0,0,1},
{0,0,1},
{0,0,1},
{0,0,1},
{0,0,1}
},
{
{1,1,1},
{0,0,1},
{1,1,1},
{1,0,0},
{1,1,1}
},
{
{1,1,1},
{0,0,1},
{1,1,1},
{0,0,1},
{1,1,1}
},
{
{1,0,1},
{1,0,1},
{1,1,1},
{0,0,1},
{0,0,1}
},
{
{1,1,1},
{1,0,0},
{1,1,1},
{0,0,1},
{1,1,1}
},
{
{1,1,1},
{1,0,0},
{1,1,1},
{1,0,1},
{1,1,1}
},
{
{1,1,1},
{0,0,1},
{0,0,1},
{0,0,1},
{0,0,1}
},
{
{1,1,1},
{1,0,1},
{1,1,1},
{1,0,1},
{1,1,1}
},
{
{1,1,1},
{1,0,1},
{1,1,1},
{0,0,1},
{1,1,1}
} };

int n, k;
char exp[ 6 ][ 512 ];
int F[ 100 ][ 15 ][ 42 ][ 22 ];
 //max stoinost za x pozicii s znak ili cifra nakraq i t zameni, s balans = b

struct parent
{
  int x; //pos
  int p; //sign
  int t; //zameni
  int b; //balans
} pred[ 96 ][ 13 ][ 41 ][ 21 ];


void init( )
{
  int i, j, N;

	DS[ 11 ][ 10 ] = -2;
	DS[ 10 ][ 11 ] = 2;


  cin >> N >> k;
  n = (N*3)+(N-1)*3;

  for ( j=1; j<=5; j++ )
  for ( i=1; i<=n; i++ )
	  cin >> exp[ j ][ i ];
}

int max( int x, int y )
{ return x > y ? x : y; }

int getsign( int x )
{
  if ( exp[ 2 ][ 3*x-2 ] == 1 )
	 return 11;
  return 10;
}

int getnum( int x )
{
 x *= 3;

 int i, j, k;

	for ( k=0; k<=9; k++ )
   {
	  for ( j=1; j<=5; j++ )
	  for ( i = x-2; i<=x; i++ )
        {
			 if ( NUMS[ k ][ j-1 ][ i-(x-2) ]+48 != exp[ j ][ i ] )
			  {
				j = 1000;
				i = 1000;
			  }
		  }


     if ( j < 1000 )
		 return k;
	}

	return 10;
}

void solve( )
{
 int p=11; //pokazva 4islo ili znak e v momenta
  int x, y, t, w, b;
 int i, j;

 for ( x=0; x<=90; x++ )
	 for ( y=0; y<=11; y++ )
		 for ( t=0; t<=40; t++ )
			 for ( b=0; b<=20; b++ )
				 F[ x ][ y ][ t ][ b ] = -1000;

 F[ 0 ][ 11 ][ 0 ][ 0 ] = 0;
 pred[ 0 ][ 11 ][ 0 ][ 0 ].x = -1;

 for ( x=0; x<=n/3; x++ )
	 for ( p=0; p<=11; p++ )
		 for ( t=0; t<=k; t++ )
			 for ( b=0; b<=k/2; b++ )
			 if ( F[ x ][ p ][ t ][ b ] != -1000 )
			 {
			   if ( p <= 9 )
            {
					int s = getsign( x+1 );

					if ( F[ x ][ p ][ t ][ b ] > F[ x+1 ][ s ][ t ][ b ] )
					{
						F[ x+1 ][ s ][ t ][ b ] = F[ x ][ p ][ t ][ b ];
						pred[ x+1 ][ s ][ t ][ b ].x = x;
						pred[ x+1 ][ s ][ t ][ b ].p = p;
						pred[ x+1 ][ s ][ t ][ b ].t = t;
						pred[ x+1 ][ s ][ t ][ b ].b = b;
					}
            	if ( F[ x ][ p ][ t ][ b ] > F[ x+1 ][ 21-s ][ t+2 ][ b+DS[ s ][ 21-s ] ] )
					  {
						F[ x+1 ][ 21-s ][ t+2 ][ b+DS[ s ][ 21-s ] ] = F[ x ][ p ][ t ][ b ];

						pred[ x+1 ][ 21-s ][ t+2 ][ b+DS[ s ][ 21-s ] ].x = x;
						pred[ x+1 ][ 21-s ][ t+2 ][ b+DS[ s ][ 21-s ] ].p = p;
						pred[ x+1 ][ 21-s ][ t+2 ][ b+DS[ s ][ 21-s ] ].t = t;
						pred[ x+1 ][ 21-s ][ t+2 ][ b+DS[ s ][ 21-s ] ].b = b;
					  }
				}
          	else
				{
				   int e = getnum( x+1 );

				 	for ( w=0; w<=9; w++ )
					{

					  if ( x == 0 || p == 11 )
                 {
						if ( F[ x ][ p ][ t ][ b ] + w > F[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ] )
						{
							F[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ] = F[ x ][ p ][ t ][ b ] + w;
							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].x = x;
							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].p = p;
							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].t = t;
							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].b = b;
						}
					  }
                 else
                 {
						if ( F[ x ][ p ][ t ][ b ] - w > F[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ] )
						{
							F[ x+1 ][ w ][ t+D[ e ][ w ] ][ b+B[ w ]-B[ e ] ] = F[ x ][ p ][ t ][ b ] - w;

							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].x = x;
							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].p = p;
							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].t = t;
							pred[ x+1 ][ w ][ t+D[ w ][ e ] ][ b+B[ w ]-B[ e ] ].b = b;
						
						}
                 }
					}
				}
			 }

	int ans = 0;
	int p1, t1;
	for ( p=0; p<=9; p++ )
	 for ( t=0; t<=k; t++ )
		 if ( F[ n/3 ][ p ][ t ][ 0 ] > ans )
       {
			ans = F[ n/3 ][ p ][ t ][ 0 ];
			p1 = p;
			t1 = t;
		 }
	p=p1;
	t=t1;
	x = n/3;
	b =0;
	cout << ans << endl;

   int x1, b1;

	while ( x > -1 )
	{
			 x1 = x;
			 p1 = p;
			 t1 = t;
			 b1 = b;
		if ( p <= 9 )
      {
		  if ( getnum( x ) != p )
        {
			 for ( j=1; j<=5; j++ )
				 for ( i=3*x-2;i<=3*x; i++ )
					exp[ j ][ i ] = NUMS[ p ][ j-1 ][ i-(3*x-2) ]+48;
		  }
		}
      else
        {
			 if ( getsign( x ) != p )
			 {
			   if ( getsign( x ) == 11 )
				  exp[ 2 ][ 3*x-1 ] = exp[ 4 ][ 3*x-1 ] = 48;
				else
				  exp[ 2 ][ 3*x-1 ] = exp[ 4 ][ 3*x-1 ] = 49;

          }
        }
		 x = pred[ x1 ][ p1 ][ t1 ][ b1 ].x;
		 p = pred[ x1 ][ p1 ][ t1 ][ b1 ].p;
		 t = pred[ x1 ][ p1 ][ t1 ][ b1 ].t;
		 b = pred[ x1 ][ p1 ][ t1 ][ b1 ].b;
	}

	for ( j=1; j<=5; j++, cout << endl )
		for ( i=1; i<=n; i++ )
			cout << exp[ j ][ i ];
}


int main( )
{

 init( );
 solve( );

 return 0;
}

