code: def decrease_exponent_to(self, new_exp):
          
          if new_exp > self.exponent:
              raise ValueError('New exponent %i should be more negative than '
                               'old exponent %i' % (new_exp, self.exponent))
          multiplied = self * pow(EncodedNumber.BASE, self.exponent - new_exp)
          multiplied.exponent = new_exp
          return multiplied
docs: Return an EncryptedNumber with same value but lower exponent.
  
          If we multiply the encoded value by :attr:`EncodedNumber.BASE` and
          decrement :attr:`exponent`, then the decoded value does not change.
          Thus we can almost arbitrarily ratchet down the exponent of an
          `EncryptedNumber` - we only run into trouble when the encoded
          integer overflows. There may not be a warning if this happens.
  
          When adding `EncryptedNumber` instances, their exponents must
          match.
  
          This method is also useful for hiding information about the
          precision of numbers - e.g. a protocol can fix the exponent of
          all transmitted `EncryptedNumber` instances to some lower bound(s).
  
          Args:
            new_exp (int): the desired exponent.
  
          Returns:
            EncryptedNumber: Instance with the same plaintext and desired
              exponent.
  
          Raises:
            ValueError: You tried to increase the exponent.