#include <iostream>

 #include <stdio.h>

 #include <string.h>  

 //精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1

 const int MN =  *  *  + ;//最大行数,共有9*9个格子，每个格子可以放1~9

 const int MM =  *  +  *  +  *  +  *  + ;//最大列数

 const int MAX_NUM = MN * MM; //最大点数  

 struct DLX

 {

     int n, m, idx;//n行数m列数idx 元素索引

                  //十字链表组成部分  

     int l[MAX_NUM], r[MAX_NUM], u[MAX_NUM], d[MAX_NUM];    //记录某个idx索引点的上下左右点的索引

     int col[MAX_NUM], row[MAX_NUM];    //两者结合使用 记录某个idx索引点的行 列号

     int nodeIdxPerRow[MAX_NUM];        //记录每行的开头节点的索引

     int nodeNumPerCol[MAX_NUM];        //记录每列节点的个数

     int ansd, ans[MN];

     void init(int n ,int m)    //初始化十字链表的 头节点和 列节点表头串   m表示有多少列

     {

         //初始化头结点和 列节点表头串 头节点数组索引 = 0  列节点表头共m个 索引 1~m

         for (int i = ; i <= m; i++) {

             r[i] = i + ;

             l[i] = i - ;

             u[i] = d[i] = i;    //列节点头串只有互相横向连接 上下连接均指向自己

         }

         r[m] = ;

         l[] = m;  //循环连接 col[m] 的右端指向头节点 头结点的左端指向clo[m]

         memset(nodeIdxPerRow, , sizeof(nodeIdxPerRow));

         memset(nodeNumPerCol, , sizeof(nodeNumPerCol));

         idx = m + ; //目前使用 0 头结点 与 m个列节点表头串 0~m 共m+1个节点

     }

     //插入节点 进行的一些数据记录

     void link(int insertRow, int insertCol)

     {

         nodeNumPerCol[insertCol]++; //插入一个节点 那么该列的节点个数+1

         row[idx] = insertRow;

         col[idx] = insertCol;    //记录第idx个节点所在的行与列

         u[idx] = insertCol;    //当前插入的节点索引记录 向上指向列节点头串中的insertCol

         d[idx] = d[insertCol];    //当前插入节点索引记录 向下指向原来列节点头串的向下指向点

         u[d[insertCol]] = idx;    //原来列节点头串指向的节点 向上由指向列节点头串指向插入的节点(使用索引)

         d[insertCol] = idx;        //列节点头串则向下指向新插入的节点(使用索引)

         //更新每行的节点记录  nodeIdxPerRow

         if (nodeIdxPerRow[insertRow] == ) {

             //如果该节点是第一个插入的节点

             nodeIdxPerRow[insertRow] = r[idx] = l[idx] = idx;//该行没有点，直接加入

         }

         else {

             //如果不是第一个插入的节点 同上面处理列次序一样 在记录和第一个节点间 插入本函数插入的节点

             r[idx] = nodeIdxPerRow[insertRow];        //新节点的右端指向原来行记录中的第一个节点

             l[idx] = l[nodeIdxPerRow[insertRow]];    //新节点的左端指向原来行记录第一个节点的左端 也就是行记录nodeIdxPerRow

             r[l[nodeIdxPerRow[insertRow]]] = idx;    //原来行记录第一个节点的左端(也就是行记录nodeIdxPerRow)的右端 指向新插入的点(使用索引)

             l[nodeIdxPerRow[insertRow]] = idx;        //原来行记录第一个节点的左端指向新插入的节点(使用索引)

         }

         idx++;

         return;

     }

     void remove(int deleteCol) {//删除涉及C列的集合

      //将要删除的列的左右两端连接起来 也等于将自己摘除出来

         r[l[deleteCol]] = r[deleteCol], l[r[deleteCol]] = l[deleteCol];

         for (int i = d[deleteCol]; i != deleteCol; i = d[i]) {

             for (int j = r[i]; j != i; j = r[j]) {

                 u[d[j]] = u[j];

                 d[u[j]] = d[j];

                 nodeNumPerCol[col[j]]--;

             }

         }

     }

     void resume(int resCol) {//恢复涉及C列的集合

         for (int i = u[resCol]; i != resCol; i = u[i]) {

             for (int j = l[i]; j != i; j = l[j]) {

                 u[d[j]] = j;

                 d[u[j]] = j;

                 nodeNumPerCol[col[j]]++;

             }

         }

         r[l[resCol]] = resCol;

         l[r[resCol]] = resCol;

     }

     bool dance(int deep) //选取了d行

     {

         if (r[] == )//全部覆盖了

         {

             //全覆盖了之后的操作

             ansd = deep;

             return ;

         }

         int c = r[];//表头结点指向的第一个列

         for (int i = r[]; i != ; i = r[i])//枚举列头指针

         {

             if (nodeNumPerCol[i] < nodeNumPerCol[c])c = i;

         }

         remove(c);//将该列删去

         for (int i = d[c]; i != c; i = d[i])

         {//枚举该列的元素

             ans[deep] = row[i];//记录该列元素的行

             for (int j = r[i]; j != i; j = r[j])

                 remove(col[j]);//将该列的某个元素的行上的元素所在的列都删去

             if (dance(deep + ))

                 return ;

             for (int j = l[i]; j != i; j = l[j])

                 resume(col[j]);

         }

         resume(c);

         return ;

     }

 }dlx;

 //==========================================================

 char s[], path[];

 struct node

 {

     int r, c, v;

 }nds[MN];

 int main()

 {

     while (~scanf("%s", s))

     {

         if (s[] == 'e')break;

         dlx.init( *  * ,  *  * );

         int r = ;

         for (int i = ; i <= ; i++)

         {

             for (int j = ; j <= ; j++)

             {

                 if (s[(i - ) *  + j - ] == '.')

                 {

                     for (int z = ; z <= ; z++)

                     {

                         dlx.link(r, (i - ) *  + j);

                         dlx.link(r,  + (i - ) *  + z);

                         dlx.link(r,  + (j - ) *  + z);

                         dlx.link(r,  + (((i - ) / ) *  + (j + ) /  - ) *  + z);

                         nds[r].r = i, nds[r].c = j, nds[r].v = z;

                         r++;

                     }

                 }

                 else

                 {

                     int z = s[(i - ) *  + j - ] - '';

                     dlx.link(r, (i - ) *  + j);

                     dlx.link(r,  + (i - ) *  + z);

                     dlx.link(r,  + (j - ) *  + z);

                     dlx.link(r,  + (((i - ) / ) *  + (j + ) /  - ) *  + z);

                     nds[r].r = i, nds[r].c = j, nds[r].v = z;

                     r++;

                 }

             }

         }

         dlx.ansd = -;

         dlx.dance();

         int deep = dlx.ansd;

         for (int i = ; i < deep; i++)

         {

             int posr = dlx.ans[i];

             path[(nds[posr].r - ) *  + nds[posr].c - ] = '' + nds[posr].v;

         }

         path[deep] = '\0';

         printf("%s\n", path);

     }

     return ;

 }