docs: def _chien_search_faster(self, sigma):
          '''Faster chien search, processing only useful coefficients (the ones in the messages) instead of the whole 2^8 range.
          Besides the speed boost, this also allows to fix a number of issue: correctly decoding when the last ecc byte is corrupted, and accepting messages of length n > 2^8.'''
          n = self.n
          X = []
          j = []
          p = GF2int(self.generator)
          # Normally we should try all 2^8 possible values, but here we optimize to just check the interesting symbols
          # This also allows to accept messages where n > 2^8.
          for l in _range(n):
              #l = (i+self.fcr)
              # These evaluations could be more efficient, but oh well
              if sigma.evaluate( p**(-l) ) == 0: # If it's 0, then bingo! It's an error location
                  # Compute the error location polynomial X (will be directly used to compute the errors magnitudes inside the Forney algorithm)
                  X.append( p**l )
                  # Compute the coefficient position (not the error position, it's actually the reverse: we compute the degree of the term where the error is located. To get the error position, just compute n-1-j).
                  # This is different than the notes, I think the notes were in error
                  # Notes said j values were just l, when it's actually 255-l
                  j.append(l)
  
          # Sanity check: the number of errors/errata positions found should be exactly the same as the length of the errata locator polynomial
          errs_nb = len(sigma) - 1 # compute the exact number of errors/errata that this error locator should find
          if len(j) != errs_nb:
              # Note: decoding messages+ecc with length n > self.gf2_charac does work partially, but it's wrong, because you will get duplicated values, and then Chien Search cannot discriminate which root is correct and which is not. The duplication of values is normally prevented by the prime polynomial reduction when generating the field (see init_lut() in ff.py), but if you overflow the field, you have no guarantee anymore. We may try to use a bruteforce approach: the correct positions ARE in the final array j, but the problem is because we are above the Galois Field's range, there is a wraparound because of overflow so that for example if j should be [0, 1, 2, 3], we will also get [255, 256, 257, 258] (because 258 % 255 == 3, same for the other values), so we can't discriminate. The issue with that bruteforce approach is that fixing any errs_nb errors among those will always give a correct output message (in the sense that the syndrome will be all 0), so we may not even be able to check if that's correct or not, so there's clearly no way to decode a message of greater length than the field.
              raise RSCodecError("Too many (or few) errors found by Chien Search for the errata locator polynomial!")
  
          return X, j