code: def _involuted_reverse(self):
          
          def inv_is_top(si):
              return (si.stride == 1 and
                  self._lower_bound == StridedInterval._modular_add(self._upper_bound, 1, self.bits)
                  )
  
          o = self.copy()
          # Clear the reversed flag
          o._reversed = not o._reversed
  
          if o.bits == 8:
              # No need for reversing
              return o.copy()
  
          if inv_is_top(o):
              # A TOP is still a TOP after reversing
              si = o.copy()
              return si
  
          else:
              lb = o._lower_bound
              ub = o._upper_bound
  
              rounded_bits = ((o.bits + 7) // 8) * 8
              lb_r = []
              ub_r = []
  
              for i in xrange(0, rounded_bits, 8):
                  if i != 0:
                      lb = lb >> 8
                      ub = ub >> 8
  
                  lb_r.append(lb & 0xff)
                  ub_r.append(ub & 0xff)
  
              si_lb = None
              si_ub = None
              for b in lb_r:
                  if si_lb is None:
                      si_lb = b
                  else:
                      si_lb <<= 8
                      si_lb |= b
              for b in ub_r:
                  if si_ub is None:
                      si_ub = b
                  else:
                      si_ub <<= 8
                      si_ub |= b
  
              si = StridedInterval(bits=o.bits,
                                   lower_bound=si_lb,
                                   upper_bound=si_ub,
                                   stride=o._stride,
                                   uninitialized=o.uninitialized)
  
              si._reversed = o._reversed
              if not o.is_integer:
                  # We really don't want to do that... but well, sometimes it just happens...
                  logger.warning('Reversing a real strided-interval %s is bad', self)
  
              return si
docs: This method reverses the StridedInterval object for real. Do expect loss of precision for most cases!
  
          :return: A new reversed StridedInterval instance