output_description: For each dataset, output the correspondence between the switches and the light
  bulbs consisting of $M$ numbers written in base-$36$. In the base-$36$ system
  for this problem, the values $0$-$9$ and $10$-$35$ are represented by the
  characters '0'-'9' and 'A'-'Z' respectively. The $i$-th character of the
  correspondence means the number of the switch controlling the $i$-th light
  bulb. If you cannot determine which switch controls the $i$-th light bulb,
  output '?' as the $i$-th character instead of the number of a switch.
input_description: The input consists of multiple datasets. The number of dataset is no more than
  $50$ and the file size is no more than $10\mathrm{MB}$. Each dataset is
  formatted as follows.
  
  > $N$ $M$ $Q$  
  > $S_1$ $B_1$  
  > :  
  > :  
  > $S_Q$ $B_Q$
  
  The first line of each dataset contains three integers $N$ ($1 \le N \le 36$),
  $M$ ($1 \le M \le 1{,}000$), $Q$ ($0 \le Q \le 1{,}000$), which denote the
  number of switches, the number of light bulbs and the number of operations
  respectively. The following $Q$ lines describe the information about the
  switches you have operated and the states of the light bulbs you have checked.
  The $i$-th of them contains two strings $S_i$ and $B_i$ of lengths $N$ and $M$
  respectively. Each $S_i$ denotes the set of the switches you have operated:
  $S_{ij}$ is either $0$ or $1$, which denotes the $j$-th switch is not operated
  or operated respectively. Each $B_i$ denotes the states of the light bulbs:
  $B_{ij}$ is either $0$ or $1$, which denotes the $j$-th light bulb is off or
  on respectively.
  
  You can assume that there exists a correspondence between the switches and the
  light bulbs which is consistent with the given information.
  
  The end of input is indicated by a line containing three zeros.
attempt: while 1:
      n, m, q = map(int, input().split())
      if (n | m | q) == 0:
          break
  
      p = []
      res = [[_ for _ in range(n)] for _ in range(m)]
      for i in range(q):
          s, b = [[int(c) for c in s] for s in input().split()]
          if i > 0:
              for j in range(n):
                  s[j] ^= p[j]
          for j in range(n):
              for k in range(m):
                  if s[j] != b[k] and j in res[k]:
                      res[k].remove(j)
          p = s
  
      table = "".join(
          [str(i) for i in range(10)] + [chr(ord("A") + i) for i in range(26)]
      )
      for i in range(m):
          if len(res[i]) == 1:
              print(table[res[i][0]], sep="", end="")
          else:
              print("?", sep="", end="")
      print()
  
problem_description: Statement
  
  In the headquarter building of ICPC (International Company of Plugs &
  Connectors), there are $M$ light bulbs and they are controlled by $N$
  switches. Each light bulb can be turned on or off by exactly one switch. Each
  switch may control multiple light bulbs. When you operate a switch, all the
  light bulbs controlled by the switch change their states. You lost the table
  that recorded the correspondence between the switches and the light bulbs, and
  want to restore it.
  
  You decided to restore the correspondence by the following procedure.
  
    * At first, every switch is off and every light bulb is off. 
    * You operate some switches represented by $S_1$. 
    * You check the states of the light bulbs represented by $B_1$. 
    * You operate some switches represented by $S_2$. 
    * You check the states of the light bulbs represented by $B_2$. 
    * ... 
    * You operate some switches represented by $S_Q$. 
    * You check the states of the light bulbs represented by $B_Q$. 
  
  After you operate some switches and check the states of the light bulbs, the
  states of the switches and the light bulbs are kept for next operations.
  
  Can you restore the correspondence between the switches and the light bulbs
  using the information about the switches you have operated and the states of
  the light bulbs you have checked?
samples: [{"input": "10 3\n    000 0000000000\n    110 0000001111\n    101 1111111100\n    2 2 0\n    1 1 0\n    2 1 1\n    01 1\n    11 11 10\n    10000000000 10000000000\n    11000000000 01000000000\n    01100000000 00100000000\n    00110000000 00010000000\n    00011000000 00001000000\n    00001100000 00000100000\n    00000110000 00000010000\n    00000011000 00000001000\n    00000001100 00000000100\n    00000000110 00000000010\n    0 0 0", "output": "??\n    0\n    1\n    0123456789A"}]