/*
TASK:expres
LANG:C++
*/

#include <stdio.h>
#include <string.h>
#include <values.h>
#include <vector>

#define IN "expres.in"
#define OUT "expres.out"

#define MINUS 11
#define PLUS 10

using namespace std;

const char * Numbers[16][5] = {{"111","101","101","101","111"},
{"001","001","001","001","001"},
{"111","001","111","100","111"},
{"111","001","111","001","111"},
{"101","101","111","001","001"},
{"111","100","111","001","111"},
{"111","100","111","101","111"},
{"111","001","001","001","001"},
{"111","101","111","101","111"},
{"111","101","111","001","111"},
{"000","010","111","010","000"},
{"000","000","111","000","000"}};

int diff[16][16] = {};
int cost[16][16] = {};
int N,K;

char str[8][128*4] = {};
char output[8][128*4] = {};
int ar[128] = {};
int sign[128] = {};


int dp[128][128][128] = {};
char vis[128][128][128] = {};
int prev[128][128][128] = {};

int write(int a,int si,int sj) {
    for (int i=si; i<si+5; i++) {
        for (int j=sj; j<sj+3; j++) {
            output[i][j] = Numbers[a][i-si][j-sj];
        }
    }
    return 0;

}

int solve () {

    for (int i=0; i<128; i++) {
        for (int j=0; j<128; j++) {
            for (int k=0; k<128; k++) {
                dp[i][j][k] = INT_MIN;
            }
        }
    }
    
    for (int i=0; i<10; i++) {
        prev[0][cost[ ar[0] ][i]][48+diff[ ar[0] ][i] ] = i;
        dp[0][cost[ ar[0] ][i]][48+diff[ ar[0] ][i] ] = i;
        vis[0][cost[ ar[0] ][i] ] [48+diff[ ar[0] ][i]] = 1;
    }

    for (int i=0; i<N-1; i++) {
        for (int j=0; j<=40; j++) { //cost
            for (int k=-40; k<=40; k++) { //diff
                if (vis[i][j][48+k]) {
                #define NEXT [i+1][j+cost[ar[i+1]][h]][48+k+diff[ar[i+1]][h]]
                #define CURRENT [i][j][48+k]
                #define SNEXT [i+1][j+cost[ar[i+1]][h]+2][48+k+diff[ar[i+1]][h]-2]
                #define SSNEXT [i+1][j+cost[ar[i+1]][h]+2][48+k+diff[ar[i+1]][h]-2]
                    if (sign[i] == PLUS) {
                        for (int h=0; h<10; h++) {
                            if (dp NEXT < dp CURRENT+h) {
                                dp NEXT = dp CURRENT+h;
                                prev NEXT = h;
                                vis NEXT = 1;
                            }
                        }
                        for (int h=0; h<10; h++) {
                            if (dp SSNEXT < dp CURRENT-h) {
                                dp SSNEXT = dp CURRENT-h;
                                prev SSNEXT = 128*h;
                                vis SSNEXT = 1;
                            }
                        }
                    } else {
                    
                        for (int h=0; h<10; h++) {
                            if (dp NEXT < dp CURRENT-h) {
                                dp NEXT = dp CURRENT-h;
                                prev NEXT = h;
                                vis NEXT = 1;
                            }
                        }
                        for (int h=0; h<10; h++) {
                            if (dp SNEXT < dp CURRENT+h) {
                                dp SNEXT = dp CURRENT+h;
                                prev SNEXT = 128*h;
                                vis SNEXT = 1;
                            }
                        }

                    }
                }
            }
        }
    }

    int Max = INT_MIN;
    int Prev = 0;
    int curDiff = 0;
    int curCost = 0;
    
    for (int i=0; i<=K; i+=2) {
        if (Max < dp[N-1][i][48]) {
            Max = dp[N-1][i][48];
            Prev = prev[N-1][i][48];
            curCost = i;
        }
    }

    int flag = 0;
    int oldPrev = Prev;
    if (Prev > 128) Prev/=128;

    for (int k=N+N-2; k>=0; k--) {
    
        if (k%2==0) {

        
            write(Prev,0,k*3);
            curCost -= cost[ar[k/2]][oldPrev];
            curDiff -= diff[ar[k/2]][oldPrev];

            if (oldPrev > 128) {
                flag = 1;
                curCost -= 2;

                if (sign[(k-1)/2] == PLUS) {
                    curDiff -= 2;
                } else {
                    curDiff += 2;
                }
            } else
                flag = 0;
                
            if (k >= 1) Prev = prev[(k-1)/2][curCost][48+curDiff];
            oldPrev = Prev;
            if (Prev >128) Prev/=128;
            
        } else {
            int SIGN = sign[k/2];
            
            if (flag) {
                if (SIGN == PLUS) SIGN = MINUS;
                else SIGN = PLUS;
            }

            write(SIGN,0,k*3);
            flag = 0;
        }
    }

    printf("%d\n",Max);
    for (int i=0; i<5; i++) {
        printf("%s\n",output[i]);
    }
    return 0;
}

pair<int,int> get_diff(int a,int b) {
    int ans1 = 0;
    int ans2 = 0;

    for (int i=0; i<5; i++) {
        for (int j=0; j<3; j++) {
            ans1 += (Numbers[a][i][j]-Numbers[b][i][j]);
            ans2 += abs(Numbers[a][i][j]-Numbers[b][i][j]);
        }
    }
    return make_pair(ans1,ans2);
}

int eq (int a,int si,int sj) {
    for (int i=si; i<si+5; i++) {
        for (int j=sj; j<sj+3; j++) {
            if (Numbers[a][i-si][j-sj] != str[i][j]) return 0;
        }
    }
    return 1;
}


int init_diff() {
    for (int i=0; i<=9; i++) {
        for (int j=0; j<=9; j++) {
            pair<int,int> p = get_diff(i,j);
            diff[i][j] = p.first;
            cost[i][j] = p.second;
        }
    }
    return 0;
}


int main () {
//    freopen(IN,"r",stdin);
//    freopen(OUT,"w",stdout);

    init_diff();
    
    scanf("%d%d\n",&N,&K);
    for (int i=0; i<5; i++) {
        for (int j=0; j<3*(N+N-1); j++) {
            scanf("%c",&str[i][j]);
        }
        scanf("\n");
    }
    
    for (int k=0; k<N+N-1; k++) {
        if (k%2==0) {
            for (int p=0; p<10; p++) {
                if (eq(p,0,k*3)) {
                    ar[k/2] = p;
                    break;
               }
            }
        } else {
             if (eq(PLUS,0,(k)*3)) {
                 sign[k/2] = PLUS;
             } else {
                 sign[k/2] = MINUS;
             }
        }
    }

    solve();
    
    return 0;
}
