# -*- coding: utf-8 -*-
# import time

sudoku = input()
# t1 = time.time()
sudoku = sudoku.replace(" ", "")

liczba_pion = 0
liczba_poziom = 0
liczba_klatka = 0



pion = [[], [], [], [], [], [], [], [], []]
poziom = [[], [], [], [], [], [], [], [], []]
klatka = [[], [], [], [], [], [], [], [], []]



# wczytanie liczb z sudoku do poziomu--------------------------------------------------------------------


for i, cyfry in enumerate(sudoku):

    if i % 9 == 0 and i != 0:

        liczba_poziom += 1

        if liczba_poziom == 9:

            liczba_poziom = 8
            break

    poziom[liczba_poziom].append(cyfry)



# wejscie w uzupełnianie sudoku----------------------------------------------------------------------------------
while ('.' in poziom[0] or '.' in poziom[1] or '.' in poziom[2] or
'.' in poziom[3] or '.' in poziom[4] or '.' in poziom[5] or
'.' in poziom[6] or '.' in poziom[7] or '.' in poziom[8] ):
    if len(sudoku) != 81:
        break
    print()
    for z in pion:
        print(z)
    print()


    
    for i in range(81):

        # wyczyszczenie pozostalej zawartosci z tablic 
        for n in range(9):
            del klatka[n][0:]
            del pion[n][0:]


        #wczytanie z poziomu dp pionu i posegregowanie na klatki
    
        for x,l in enumerate(poziom):
            for j, liczby in enumerate(poziom[x]):

                if (j == 0 or j == 1 or j == 2) and x <= 2:
                    klatka[0].append(liczby)
                elif (j == 3 or j == 4 or j == 5) and x <= 2:
                    klatka[1].append(liczby)
                elif (j == 6 or j == 7 or j == 8) and x <= 2:
                    klatka[2].append(liczby)
                elif (j == 0 or j == 1 or j == 2) and (x > 2 and x <= 5):
                    klatka[3].append(liczby)
                elif (j == 3 or j == 4 or j == 5) and (x > 2 and x <= 5):
                    klatka[4].append(liczby)
                elif (j == 6 or j == 7 or j == 8) and (x > 2 and x <= 5):
                    klatka[5].append(liczby)
                elif (j == 0 or j == 1 or j == 2) and (x > 5 and x <= 8):
                    klatka[6].append(liczby)
                elif (j == 3 or j == 4 or j == 5) and (x > 5 and x <= 8):
                    klatka[7].append(liczby)
                elif (j == 6 or j == 7 or j == 8) and (x > 5 and x <= 8):
                    klatka[8].append(liczby)

                pion[j].append(liczby)



        # w zaleznosci od i dopasowanie do klatki poziomu i pionu
        if (
            i == 0
            or i == 1
            or i == 2
            or i == 9
            or i == 10
            or i == 11
            or i == 18
            or i == 19
            or i == 20
        ):

            liczba_klatka = 0

            if i == 0 or i == 1 or i == 2:
                liczba_poziom = 0
            elif i == 9 or i == 10 or i == 11:
                liczba_poziom = 1
            elif i == 18 or i == 19 or i == 20:
                liczba_poziom = 2

            if i % 3 == 0:
                liczba_pion = 0
            elif i % 3 == 1:
                liczba_pion = 1
            elif i % 3 == 2:
                liczba_pion = 2

        elif (
            i == 3
            or i == 4
            or i == 5
            or i == 12
            or i == 13
            or i == 14
            or i == 21
            or i == 22
            or i == 23
        ):

            liczba_klatka = 1

            if i == 3 or i == 4 or i == 5:
                liczba_poziom = 0
            elif i == 12 or i == 13 or i == 14:
                liczba_poziom = 1
            elif i == 21 or i == 22 or i == 23:
                liczba_poziom = 2

            if i % 3 == 0:
                liczba_pion = 3
            elif i % 3 == 1:
                liczba_pion = 4
            elif i % 3 == 2:
                liczba_pion = 5

        elif (
            i == 6
            or i == 7
            or i == 8
            or i == 15
            or i == 16
            or i == 17
            or i == 24
            or i == 25
            or i == 26
        ):

            liczba_klatka = 2

            if i == 6 or i == 7 or i == 8:
                liczba_poziom = 0
            elif i == 15 or i == 16 or i == 17:
                liczba_poziom = 1
            elif i == 24 or i == 25 or i == 26:
                liczba_poziom = 2

            if i % 3 == 0:
                liczba_pion = 6
            elif i % 3 == 1:
                liczba_pion = 7
            elif i % 3 == 2:
                liczba_pion = 8
        # ------------------------------------------------------------------------------------------------------------------
        elif (
            i == 27
            or i == 28
            or i == 29
            or i == 36
            or i == 37
            or i == 38
            or i == 45
            or i == 46
            or i == 47
        ):

            liczba_klatka = 3

            if i == 27 or i == 28 or i == 29:
                liczba_poziom = 3
            elif i == 36 or i == 37 or i == 38:
                liczba_poziom = 4
            elif i == 47 or i == 46 or i == 45:
                liczba_poziom = 5

            if i % 3 == 0:
                liczba_pion = 0
            elif i % 3 == 1:
                liczba_pion = 1
            elif i % 3 == 2:
                liczba_pion = 2

        elif (
            i == 30
            or i == 31
            or i == 32
            or i == 39
            or i == 40
            or i == 41
            or i == 48
            or i == 49
            or i == 50
        ):

            liczba_klatka = 4

            if i == 30 or i == 31 or i == 32:
                liczba_poziom = 3
            elif i == 39 or i == 40 or i == 41:
                liczba_poziom = 4
            elif i == 48 or i == 49 or i == 50:
                liczba_poziom = 5

            if i % 3 == 0:
                liczba_pion = 3
            elif i % 3 == 1:
                liczba_pion = 4
            elif i % 3 == 2:
                liczba_pion = 5

        elif (
            i == 33
            or i == 34
            or i == 35
            or i == 42
            or i == 43
            or i == 44
            or i == 51
            or i == 52
            or i == 53
        ):

            liczba_klatka = 5

            if i == 33 or i == 34 or i == 35:
                liczba_poziom = 3
            elif i == 42 or i == 43 or i == 44:
                liczba_poziom = 4
            elif i == 51 or i == 52 or i == 53:
                liczba_poziom = 5

            if i % 3 == 0:
                liczba_pion = 6
            elif i % 3 == 1:
                liczba_pion = 7
            elif i % 3 == 2:
                liczba_pion = 8

        # -----------------------------------------------------------------------------------------------------------------

        elif (
            i == 54
            or i == 55
            or i == 56
            or i == 63
            or i == 64
            or i == 65
            or i == 72
            or i == 73
            or i == 74
        ):

            liczba_klatka = 6

            if i == 54 or i == 55 or i == 56:
                liczba_poziom = 6
            elif i == 63 or i == 64 or i == 65:
                liczba_poziom = 7
            elif i == 72 or i == 73 or i == 74:
                liczba_poziom = 8

            if i % 3 == 0:
                liczba_pion = 0
            elif i % 3 == 1:
                liczba_pion = 1
            elif i % 3 == 2:
                liczba_pion = 2

        elif (
            i == 57
            or i == 58
            or i == 59
            or i == 66
            or i == 67
            or i == 68
            or i == 75
            or i == 76
            or i == 77
        ):

            liczba_klatka = 7

            if i == 57 or i == 58 or i == 59:
                liczba_poziom = 6
            elif i == 66 or i == 67 or i == 68:
                liczba_poziom = 7
            elif i == 75 or i == 76 or i == 77:
                liczba_poziom = 8

            if i % 3 == 0:
                liczba_pion = 3
            elif i % 3 == 1:
                liczba_pion = 4
            elif i % 3 == 2:
                liczba_pion = 5

        elif (
            i == 60
            or i == 61
            or i == 62
            or i == 69
            or i == 70
            or i == 71
            or i == 78
            or i == 79
            or i == 80
        ):

            liczba_klatka = 8

            if i == 60 or i == 61 or i == 62:
                liczba_poziom = 6
            elif i == 69 or i == 70 or i == 71:
                liczba_poziom = 7
            elif i == 78 or i == 79 or i == 80:
                liczba_poziom = 8

            if i % 3 == 0:
                liczba_pion = 6
            elif i % 3 == 1:
                liczba_pion = 7
            elif i % 3 == 2:
                liczba_pion = 8

        
        #----------------------------------------------------------------------------------------------------------
# wejscie do petli z warunkami kotre liczba musi spelnic liczby ida od 1 do 9 i po kolei sa srawdzane    

        for x in range(1, 10):
            j = str(x)

            if j in klatka[liczba_klatka]:
                continue
            if j in poziom[liczba_poziom]:
                continue
            if j in pion[liczba_pion]:
                continue
            if poziom[liczba_poziom][i%9] != '.':
                break
        

            if liczba_pion % 3 == 0:

                if liczba_poziom % 3 == 0:

                    # warunek z dwiema cyframi------------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][3] != "."
                        and klatka[liczba_klatka][6] != "."
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                   
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][1] != "."
                        and klatka[liczba_klatka][2] != "."
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                    ):
                      
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z jedna cyfra---------------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][2] != "."
                    ):
                       
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 2])
                        and klatka[liczba_klatka][1] != "."
                    ):
              
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][6] != "."
                    ):
                
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom + 2])
                        and klatka[liczba_klatka][3] != "."
                    ):
              
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                #???????????????????????????????????????????????????????????????????????????????????????????

                elif liczba_poziom % 3 == 1:

                    # warunek z dwiema cyframi-------------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][4] != "."
                        and klatka[liczba_klatka][5] != "."
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != "."
                        and klatka[liczba_klatka][6] != "."
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z jedna cyfra---------------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 2])
                        and klatka[liczba_klatka][4] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][5] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][0] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][6] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                #???????????????????????????????????????????????????????????????????????????????????????????

                elif liczba_poziom % 3 == 2:
                    
                    # warunek z dwoma cyframi-----------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][3] != "."
                        and klatka[liczba_klatka][0] != "."
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][8] != "."
                        and klatka[liczba_klatka][7] != "."
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z jedna cyfra-----------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][8] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 2])
                        and klatka[liczba_klatka][7] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][0] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                        and (j in poziom[liczba_poziom - 2])
                        and klatka[liczba_klatka][3] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                #???????????????????????????????????????????????????????????????????????????????????????????
            # --------------------------------------------------------------------------------------------------

            elif liczba_pion % 3 == 1:

                if liczba_poziom % 3 == 0:

                    # warunek z dwiema cyframi-----------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][4] != "."
                        and klatka[liczba_klatka][7] != "."
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][2] != "."
                        and klatka[liczba_klatka][0] != "."
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z jedna cyfra-----------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][0] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][2] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom + 2])
                        and klatka[liczba_klatka][4] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][7] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 2])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                
                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                #???????????????????????????????????????????????????????????????????????????????????????????

                elif liczba_poziom % 3 == 1:

                    # warunek z dwiema cyframi-----------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][1] != "."
                        and klatka[liczba_klatka][7] != "."
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][5] != "."
                        and klatka[liczba_klatka][3] != "."
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z jedna cyfra-----------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][5] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][3] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][1] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][7] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                #???????????????????????????????????????????????????????????????????????????????????????????

                elif liczba_poziom % 3 == 2:
                    
                    # warunek z dwiema cyframi-----------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][1] != "."
                        and klatka[liczba_klatka][4] != "."
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                        

                    elif (
                        klatka[liczba_klatka][8] != "."
                        and klatka[liczba_klatka][6] != "."
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                    ):

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    # warunek z jedna cyfra-----------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][8] != "."
                    ):

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                        and klatka[liczba_klatka][6] != "."
                    ):

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][1] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and klatka[liczba_klatka][4] != '.'
                    ):

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                        and (j in pion[liczba_pion - 1])
                    ):

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion + 1])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                #???????????????????????????????????????????????????????????????????????????????????????????

            # ---------------------------------------------------------------------------------------------------

            elif liczba_pion % 3 == 2:

                if liczba_poziom % 3 == 0:
                    
                    # warunek z dwiema cyframi-----------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][5] != "."
                        and klatka[liczba_klatka][8] != "."
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != "."
                        and klatka[liczba_klatka][1] != "."
                        and (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z jedna cyfra-----------------------------------------------------------------


                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][0] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 2])
                        and klatka[liczba_klatka][1] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][8] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom + 2])
                        and klatka[liczba_klatka][5] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and (j in poziom[liczba_poziom + 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                #???????????????????????????????????????????????????????????????????????????????????????????

                elif liczba_poziom % 3 == 1:

                    # warunek z dwiema cyframi-----------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][2] != "."
                        and klatka[liczba_klatka][8] != "."
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('1',i)
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][4] != "."
                        and klatka[liczba_klatka][3] != "."
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        print('2',i)

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z jedna cyfra-----------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][3] != "."
                    ):
                        print('3',i)

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 2])
                        and klatka[liczba_klatka][4] != "."
                    ):
                        print('4',i)

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom + 1])
                        and klatka[liczba_klatka][2] != "."
                    ):
                        print('5',i)

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][8] != '.'
                    ):
                        print('6',i)

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom + 1])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('7',i)

                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        print('8',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('9',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 1])
                    ):
                        print('10',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        print('11',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('12',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        print('13',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][8] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        print('14',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and (j in poziom[liczba_poziom + 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        print('15',i)
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    
                    
                #???????????????????????????????????????????????????????????????????????????????????????????

                elif liczba_poziom % 3 == 2:
                    # warunek z dwiema cyframi-----------------------------------------------------------------

                    if (
                        klatka[liczba_klatka][2] != "."
                        and klatka[liczba_klatka][5] != "."
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][6] != "."
                        and klatka[liczba_klatka][7] != "."
                        and (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z jedna cyfra-----------------------------------------------------------------

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                        and klatka[liczba_klatka][6] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 1])
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 2])
                        and klatka[liczba_klatka][7] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and klatka[liczba_klatka][2] != "."
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                        and (j in poziom[liczba_poziom - 2])
                        and klatka[liczba_klatka][5] != '.'
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        (j in poziom[liczba_poziom - 2])
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z pięcioma cyframi-----------------------------------------------------------------
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                   
                    elif (
                        klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    # warunek z trzema cyframi -------------------------------------------------------------

                    elif (
                        klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][7] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 2])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 2])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                    elif (
                        klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and (j in poziom[liczba_poziom - 1])
                        and (j in pion[liczba_pion - 1])
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)
                    
                    # warunek z ostatnia cyfra--------------------------------------------------------------
                    #klatka
                    elif (
                        j not in klatka[liczba_klatka] 
                        and klatka[liczba_klatka][0] != '.'
                        and klatka[liczba_klatka][1] != '.'
                        and klatka[liczba_klatka][2] != '.'
                        and klatka[liczba_klatka][3] != '.'
                        and klatka[liczba_klatka][4] != '.'
                        and klatka[liczba_klatka][5] != '.'
                        and klatka[liczba_klatka][6] != '.'
                        and klatka[liczba_klatka][7] != '.'
                    ):
                        
                        poziom[liczba_poziom].pop(i%9)
                        poziom[liczba_poziom].insert(i%9,j)

                #???????????????????????????????????????????????????????????????????????????????????????????


for z in poziom:
    print(z)