//#include "ada.hh"
#include <iostream>
#include <vector>
using namespace std;

typedef int boolean;

template <typename T>
class matrix {

    int r,c;
    vector<vector<T> > t;

public:

    matrix () :
        r(0), c(0) {  }

    matrix (int files, int columnes, T init=T()) :
        r(files), c(columnes), t(vector<vector<T> >(r, vector<T>(c,init))) {  }

    int rows () const {
        return r;
    }

    int cols () const {
        return c;
    }

    vector<T>& operator[] (int i) {
        return t[i];
    }

    const vector<T>& operator[] (int i) const {
        return t[i];
    }


    friend ostream& operator<< (ostream& s, matrix<T> m) {
        for (int j=0; j<m.c; ++j) {
            for (int i=0; i<m.r; ++i) {
                s << m.t[i][j] << " ";
            }
            s << endl;
        }
        return s;
    }
};

class Sudoku {

    int n;              // nombre de files i columnes
    matrix<int> Q;      // el sudoku
    matrix<boolean> F;  // F[i][c] = c Es lliure per fila i
    matrix<boolean> C;  // C[j][c] = c Es lliure per columna j
	matrix<boolean> S;	// S[k][c] = c Es lliure per al k-essim subquadrat

	bool omplir()
	{
		/*Recorrem la matriu d'entrada per actualitzar
		els controladors de factibilitat*/
		for (int i=0; i<n; i++)
		{
			for (int j=0; j<n; j++)
			{
				if (Q[i][j]!=0)
				{
					if (F[i][Q[i][j]-1]==false || C[j][Q[i][j]-1]==false || S[j/3+(i/3)*3][Q[i][j]-1]==false) return false;
					F[i][Q[i][j]-1] = false;
					C[j][Q[i][j]-1] = false;
					S[j/3+(i/3)*3][Q[i][j]-1] = false;
				}
			}
		}
		return true;
	}


	bool recursiu (int cas)
	{
		boolean ok=false;
		/*Cas base soluci— trobada*/
		if (cas==n*n)
		{	
            /*Escrivim el tauler resolt*/
			cout << endl;
			for (int fil=0; fil<n; fil++)
			{
				for (int col=0; col<n;col++)
				{
					cout << Q[fil][col];
					if (col!=8) cout << " ";
					if (col==2 || col==5) 
					{
						cout << "|";
						cout << " ";
					}
				}
				if (fil!=8) cout << endl;
				if (fil==2 || fil==5)
				{
					cout << "---------------------";
					cout << endl;
				}
			}
			cout << endl;
			return true;
        }
		else
		{
			int i = cas/n, j = cas%n;
			/*Si la casella ja es plena, mirem la seguent*/
			if (Q[i][j]!=0) return recursiu(cas+1);

			/*La casella es buida*/
			else
			{
				/*Iterem sobre cada possible valor de la casella*/
				for (int c=1; c<=n; ++c)
				{
					
					/*Si es factible*/
					if (F[i][c-1] and C[j][c-1] and S[j/3+(i/3)*3][c-1])
					{
						ok=true;
						/*Marquem:
						casella amb valor c i fil, col, i subquadre ocupats*/
						Q[i][j] = c;
						F[i][c-1] = C[j][c-1] = S[j/3+(i/3)*3][c-1] = false;

						/*Cridem recursivament pel segŸent cas*/
						recursiu(cas+1);

						/*Desmarquem:
						casella amb valor 0 i fil, col i subquadre lliures*/
						Q[i][j]=0;
						F[i][c-1] = C[j][c-1] = S[j/3+(i/3)*3][c-1] = true;
					}
				}
				if (ok==false) return false;	
			}
		}
		return true;
	}


public:

    Sudoku (int nombre)
	{
        this->n = nombre;
		Q = matrix<int>(n,n);
		int i, j;
		i = j = 0;
		char c;
		while (j < 9)
		{
			cin >> c;
			if (c <= '9' and c >= '0')
			{
				Q[j][i] = c-'0';
				++i;
				if (i == 9)
				{
					i = 0;
					++j;
				}
			}
		}
		//cout << Q;

        F       = matrix<boolean>(n,n,true);
        C       = matrix<boolean>(n,n,true);
		S       = matrix<boolean>(n,n,true);
		/*if(omplir()) 
		{
			if (!recursiu(0)) cout << "sense solucio" << endl;
		}
		else cout << "sense solucio" << endl;*/
		//if (omplir())
		//{
		//	cout << "entro aqui";
			if ((!omplir())) cout << "sense solucio";
			else
			{
				if (!recursiu(0)) cout << "sense solucio" << endl;
			
			 }
		//else cout << "sense solucio";
		
    }
};

/** Programa principal **/

int main ()
{
   Sudoku sk(9);
}