Minor text rearrangement.

diff --cc Lib/collections.py
index 77ba11b18975cf732601deea325d48edb16bcf77,b2a590bd7715813f614a10a580bea1590c29913b..580b11c969e15f96f5ec46416a203af249437079
--- 1/Lib/collections.py
--- 2/Lib/collections.py
+++ b/Lib/collections.py
@@@ -97,79 -98,6 +97,69 @@@ class OrderedDict(dict)
              yield curr.key
              curr = curr.prev
  
-     def __reduce__(self):
-         'Return state information for pickling'
-         items = [[k, self[k]] for k in self]
-         inst_dict = vars(self).copy()
-         for k in vars(OrderedDict()):
-             inst_dict.pop(k, None)
-         if inst_dict:
-             return (self.__class__, (items,), inst_dict)
-         return self.__class__, (items,)
- 
 +    def clear(self):
 +        'od.clear() -> None.  Remove all items from od.'
 +        root = self.__root
 +        root.prev = root.next = root
 +        self.__map.clear()
 +        dict.clear(self)
 +
 +    def popitem(self, last=True):
 +        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
 +        Pairs are returned in LIFO order if last is true or FIFO order if false.
 +
 +        '''
 +        if not self:
 +            raise KeyError('dictionary is empty')
 +        root = self.__root
 +        if last:
 +            link = root.prev
 +            link_prev = link.prev
 +            link_prev.next = root
 +            root.prev = link_prev
 +        else:
 +            link = root.next
 +            link_next = link.next
 +            root.next = link_next
 +            link_next.prev = root
 +        key = link.key
 +        del self.__map[key]
 +        value = dict.pop(self, key)
 +        return key, value
 +
 +    def move_to_end(self, key, last=True):
 +        '''Move an existing element to the end (or beginning if last==False).
 +
 +        Raises KeyError if the element does not exist.
 +        When last=True, acts like a fast version of self[key]=self.pop(key).
 +
 +        '''
 +        link = self.__map[key]
 +        link_prev = link.prev
 +        link_next = link.next
 +        link_prev.next = link_next
 +        link_next.prev = link_prev
 +        root = self.__root
 +        if last:
 +            last = root.prev
 +            link.prev = last
 +            link.next = root
 +            last.next = root.prev = link
 +        else:
 +            first = root.next
 +            link.prev = root
 +            link.next = first
 +            root.next = first.prev = link
 +
 +    def __sizeof__(self):
 +        sizeof = _sys.getsizeof
 +        n = len(self) + 1                       # number of links including root
 +        size = sizeof(self.__dict__)            # instance dictionary
 +        size += sizeof(self.__map) * 2          # internal dict and inherited dict
 +        size += sizeof(self.__hardroot) * n     # link objects
 +        size += sizeof(self.__root) * n         # proxy objects
 +        return size
 +
      update = __update = MutableMapping.update
      keys = MutableMapping.keys
      values = MutableMapping.values
@@@ -194,13 -122,40 +184,23 @@@
          self[key] = default
          return default
  
 -    def popitem(self, last=True):
 -        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
 -        Pairs are returned in LIFO order if last is true or FIFO order if false.
 -
 -        '''
 -        if not self:
 -            raise KeyError('dictionary is empty')
 -        key = next(reversed(self) if last else iter(self))
 -        value = self.pop(key)
 -        return key, value
 -
 +    @_recursive_repr()
      def __repr__(self):
          'od.__repr__() <==> repr(od)'
 -        if self.__in_repr:
 -            return '...'
          if not self:
              return '%s()' % (self.__class__.__name__,)
 -        self.__in_repr = True
 -        try:
 -            result = '%s(%r)' % (self.__class__.__name__, list(self.items()))
 -        finally:
 -            self.__in_repr = False
 -        return result
 +        return '%s(%r)' % (self.__class__.__name__, list(self.items()))
  
+     def __reduce__(self):
+         'Return state information for pickling'
+         items = [[k, self[k]] for k in self]
+         inst_dict = vars(self).copy()
+         for k in vars(OrderedDict()):
+             inst_dict.pop(k, None)
+         if inst_dict:
+             return (self.__class__, (items,), inst_dict)
+         return self.__class__, (items,)
+ 
      def copy(self):
          'od.copy() -> a shallow copy of od'
          return self.__class__(self)