1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import sys

def solve():
    first_line = sys.stdin.readline().strip()
    if not first_line:
        return
    whoami = first_line
    line2 = sys.stdin.readline().split()
    n = int(line2[0])
    t = int(line2[1])
    
    MASKS = [0x55555555555555, 0x2AAAAAAAAAAAAA]
    
    def decode(M):
        valid_X = set()
        for r0 in range(8):
            for r1 in range(r0+1, 9):
                for r2 in range(r1+1, 10):
                    for c0 in range(9):
                        for c1 in range(c0+1, 10):
                            if M[r0][c0]==0 or M[r0][c1]==0 or \
                               M[r1][c0]==0 or M[r1][c1]==0 or \
                               M[r2][c0]==0 or M[r2][c1]==0:
                                continue
                            
                            rem_c = [c for c in range(10) if c != c0 and c != c1]
                            sig_c = [(M[r0][c]<<2) | (M[r1][c]<<1) | M[r2][c] for c in rem_c]
                            
                            if len(set(sig_c)) != 8:
                                continue
                                
                            rem_r = [r for r in range(10) if r != r0 and r != r1 and r != r2]
                            sig_r = [(M[r][c0]<<1) | M[r][c1] for r in rem_r]
                                
                            counts = [sig_r.count(i) for i in range(4)]
                            if counts != [2, 2, 2, 1]:
                                continue
                                
                            dcols = [0]*8
                            for i, c in enumerate(rem_c):
                                dcols[sig_c[i]] = c
                                
                            groups = {0:[], 1:[], 2:[], 3:[]}
                            for i, r in enumerate(rem_r):
                                groups[sig_r[i]].append(r)
                                
                            drows = []
                            for g in range(4):
                                groups[g].sort(key=lambda r: sum(M[r][dcols[k]] << (7-k) for k in range(8)))
                                drows.extend(groups[g])
                                
                            enc_x = 0
                            for dr in drows:
                                for dc in dcols:
                                    enc_x = (enc_x << 1) | M[dr][dc]
                            
                            mask_idx = enc_x & 1
                            enc_x >>= 1
                            
                            X = enc_x ^ MASKS[mask_idx]
                            valid_X.add(X)
        return valid_X

    if whoami == "Algosia":
        for _ in range(t):
            line = sys.stdin.readline().strip()
            if not line: break
            x = int(line)
            
            best_M = None
            for mask_idx in range(2):
                enc_x = x ^ MASKS[mask_idx]
                
                M = [[0]*10 for _ in range(10)]
                for r in range(3):
                    M[r][0] = 1
                    M[r][1] = 1
                    
                for i in range(8):
                    M[0][i+2] = (i >> 2) & 1
                    M[1][i+2] = (i >> 1) & 1
                    M[2][i+2] = i & 1
                    
                sigs = [0, 0, 1, 1, 2, 2, 3]
                for i in range(7):
                    M[i+3][0] = (sigs[i] >> 1) & 1
                    M[i+3][1] = sigs[i] & 1
                    
                data_bits = []
                for i in range(54, -1, -1):
                    data_bits.append((enc_x >> i) & 1)
                data_bits.append(mask_idx)
                
                bit_idx = 0
                for r in range(7):
                    for c in range(8):
                        M[r+3][c+2] = data_bits[bit_idx]
                        bit_idx += 1
                        
                valid_X = decode(M)
                if len(valid_X) == 1 and list(valid_X)[0] == x:
                    best_M = M
                    break
                    
            if best_M is None:
                best_M = M
                
            for row in best_M:
                sys.stdout.write("".join(map(str, row)) + "\n")
            sys.stdout.flush()
            
    else:
        for _ in range(t):
            M = []
            for _ in range(10):
                M.append([int(c) for c in sys.stdin.readline().strip()])
            
            valid_X = decode(M)
            ans = list(valid_X)[0]
            sys.stdout.write(str(ans) + "\n")
            sys.stdout.flush()

if __name__ == '__main__':
    solve()