docs: def make_error_block(self, block, block_number):
          """This function constructs the error correction block of the
          given data block. This is *very complicated* process. To
          understand the code you need to read:
  
          * http://www.thonky.com/qr-code-tutorial/part-2-error-correction/
          * http://www.matchadesign.com/blog/qr-code-demystified-part-4/
          """
          #Get the error information from the standards table
          error_info = tables.eccwbi[self.version][self.error]
  
          #This is the number of 8-bit words per block
          if block_number < error_info[1]:
              code_words_per_block = error_info[2]
          else:
              code_words_per_block = error_info[4]
  
          #This is the size of the error block
          error_block_size = error_info[0]
  
          #Copy the block as the message polynomial coefficients
          mp_co = block[:]
  
          #Add the error blocks to the message polynomial
          mp_co.extend([0] * (error_block_size))
  
          #Get the generator polynomial
          generator = tables.generator_polynomials[error_block_size]
  
          #This will hold the temporary sum of the message coefficient and the
          #generator polynomial
          gen_result = [0] * len(generator)
  
          #Go through every code word in the block
          for i in range(code_words_per_block):
              #Get the first coefficient from the message polynomial
              coefficient = mp_co.pop(0)
  
              #Skip coefficients that are zero
              if coefficient == 0:
                  continue
              else:
                  #Turn the coefficient into an alpha exponent
                  alpha_exp = tables.galois_antilog[coefficient]
  
              #Add the alpha to the generator polynomial
              for n in range(len(generator)):
                  gen_result[n] = alpha_exp + generator[n]
                  if gen_result[n] > 255:
                      gen_result[n] = gen_result[n] % 255
  
                  #Convert the alpha notation back into coefficients
                  gen_result[n] = tables.galois_log[gen_result[n]]
  
                  #XOR the sum with the message coefficients
                  mp_co[n] = gen_result[n] ^ mp_co[n]
  
          #Pad the end of the error blocks with zeros if needed
          if len(mp_co) < code_words_per_block:
              mp_co.extend([0] * (code_words_per_block - len(mp_co)))
  
          return mp_co