Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1008 insertions, 1008 deletions

diff --git a/contrib/tools/python3/src/Lib/_collections_abc.py b/contrib/tools/python3/src/Lib/_collections_abc.py
index acfaff802f..21f7f8c12c 100644
--- a/contrib/tools/python3/src/Lib/_collections_abc.py
+++ b/contrib/tools/python3/src/Lib/_collections_abc.py
@@ -1,417 +1,417 @@
-# Copyright 2007 Google, Inc. All Rights Reserved.
-# Licensed to PSF under a Contributor Agreement.
-
-"""Abstract Base Classes (ABCs) for collections, according to PEP 3119.
-
-Unit tests are in test_collections.
-"""
-
-from abc import ABCMeta, abstractmethod
-import sys
-
+# Copyright 2007 Google, Inc. All Rights Reserved. 
+# Licensed to PSF under a Contributor Agreement. 
+ 
+"""Abstract Base Classes (ABCs) for collections, according to PEP 3119. 
+ 
+Unit tests are in test_collections. 
+""" 
+ 
+from abc import ABCMeta, abstractmethod 
+import sys 
+ 
 GenericAlias = type(list[int])
 EllipsisType = type(...)
 def _f(): pass
 FunctionType = type(_f)
 del _f
 
-__all__ = ["Awaitable", "Coroutine",
-           "AsyncIterable", "AsyncIterator", "AsyncGenerator",
-           "Hashable", "Iterable", "Iterator", "Generator", "Reversible",
-           "Sized", "Container", "Callable", "Collection",
-           "Set", "MutableSet",
-           "Mapping", "MutableMapping",
-           "MappingView", "KeysView", "ItemsView", "ValuesView",
-           "Sequence", "MutableSequence",
-           "ByteString",
-           ]
-
-# This module has been renamed from collections.abc to _collections_abc to
-# speed up interpreter startup. Some of the types such as MutableMapping are
-# required early but collections module imports a lot of other modules.
-# See issue #19218
-__name__ = "collections.abc"
-
-# Private list of types that we want to register with the various ABCs
-# so that they will pass tests like:
-#       it = iter(somebytearray)
-#       assert isinstance(it, Iterable)
-# Note:  in other implementations, these types might not be distinct
-# and they may have their own implementation specific types that
-# are not included on this list.
-bytes_iterator = type(iter(b''))
-bytearray_iterator = type(iter(bytearray()))
-#callable_iterator = ???
-dict_keyiterator = type(iter({}.keys()))
-dict_valueiterator = type(iter({}.values()))
-dict_itemiterator = type(iter({}.items()))
-list_iterator = type(iter([]))
-list_reverseiterator = type(iter(reversed([])))
-range_iterator = type(iter(range(0)))
-longrange_iterator = type(iter(range(1 << 1000)))
-set_iterator = type(iter(set()))
-str_iterator = type(iter(""))
-tuple_iterator = type(iter(()))
-zip_iterator = type(iter(zip()))
-## views ##
-dict_keys = type({}.keys())
-dict_values = type({}.values())
-dict_items = type({}.items())
-## misc ##
-mappingproxy = type(type.__dict__)
-generator = type((lambda: (yield))())
-## coroutine ##
-async def _coro(): pass
-_coro = _coro()
-coroutine = type(_coro)
-_coro.close()  # Prevent ResourceWarning
-del _coro
-## asynchronous generator ##
-async def _ag(): yield
-_ag = _ag()
-async_generator = type(_ag)
-del _ag
-
-
-### ONE-TRICK PONIES ###
-
-def _check_methods(C, *methods):
-    mro = C.__mro__
-    for method in methods:
-        for B in mro:
-            if method in B.__dict__:
-                if B.__dict__[method] is None:
-                    return NotImplemented
-                break
-        else:
-            return NotImplemented
-    return True
-
-class Hashable(metaclass=ABCMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __hash__(self):
-        return 0
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Hashable:
-            return _check_methods(C, "__hash__")
-        return NotImplemented
-
-
-class Awaitable(metaclass=ABCMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __await__(self):
-        yield
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Awaitable:
-            return _check_methods(C, "__await__")
-        return NotImplemented
-
+__all__ = ["Awaitable", "Coroutine", 
+           "AsyncIterable", "AsyncIterator", "AsyncGenerator", 
+           "Hashable", "Iterable", "Iterator", "Generator", "Reversible", 
+           "Sized", "Container", "Callable", "Collection", 
+           "Set", "MutableSet", 
+           "Mapping", "MutableMapping", 
+           "MappingView", "KeysView", "ItemsView", "ValuesView", 
+           "Sequence", "MutableSequence", 
+           "ByteString", 
+           ] 
+ 
+# This module has been renamed from collections.abc to _collections_abc to 
+# speed up interpreter startup. Some of the types such as MutableMapping are 
+# required early but collections module imports a lot of other modules. 
+# See issue #19218 
+__name__ = "collections.abc" 
+ 
+# Private list of types that we want to register with the various ABCs 
+# so that they will pass tests like: 
+#       it = iter(somebytearray) 
+#       assert isinstance(it, Iterable) 
+# Note:  in other implementations, these types might not be distinct 
+# and they may have their own implementation specific types that 
+# are not included on this list. 
+bytes_iterator = type(iter(b'')) 
+bytearray_iterator = type(iter(bytearray())) 
+#callable_iterator = ??? 
+dict_keyiterator = type(iter({}.keys())) 
+dict_valueiterator = type(iter({}.values())) 
+dict_itemiterator = type(iter({}.items())) 
+list_iterator = type(iter([])) 
+list_reverseiterator = type(iter(reversed([]))) 
+range_iterator = type(iter(range(0))) 
+longrange_iterator = type(iter(range(1 << 1000))) 
+set_iterator = type(iter(set())) 
+str_iterator = type(iter("")) 
+tuple_iterator = type(iter(())) 
+zip_iterator = type(iter(zip())) 
+## views ## 
+dict_keys = type({}.keys()) 
+dict_values = type({}.values()) 
+dict_items = type({}.items()) 
+## misc ## 
+mappingproxy = type(type.__dict__) 
+generator = type((lambda: (yield))()) 
+## coroutine ## 
+async def _coro(): pass 
+_coro = _coro() 
+coroutine = type(_coro) 
+_coro.close()  # Prevent ResourceWarning 
+del _coro 
+## asynchronous generator ## 
+async def _ag(): yield 
+_ag = _ag() 
+async_generator = type(_ag) 
+del _ag 
+ 
+ 
+### ONE-TRICK PONIES ### 
+ 
+def _check_methods(C, *methods): 
+    mro = C.__mro__ 
+    for method in methods: 
+        for B in mro: 
+            if method in B.__dict__: 
+                if B.__dict__[method] is None: 
+                    return NotImplemented 
+                break 
+        else: 
+            return NotImplemented 
+    return True 
+ 
+class Hashable(metaclass=ABCMeta): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __hash__(self): 
+        return 0 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Hashable: 
+            return _check_methods(C, "__hash__") 
+        return NotImplemented 
+ 
+ 
+class Awaitable(metaclass=ABCMeta): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __await__(self): 
+        yield 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Awaitable: 
+            return _check_methods(C, "__await__") 
+        return NotImplemented 
+ 
     __class_getitem__ = classmethod(GenericAlias)
-
-
-class Coroutine(Awaitable):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def send(self, value):
-        """Send a value into the coroutine.
-        Return next yielded value or raise StopIteration.
-        """
-        raise StopIteration
-
-    @abstractmethod
-    def throw(self, typ, val=None, tb=None):
-        """Raise an exception in the coroutine.
-        Return next yielded value or raise StopIteration.
-        """
-        if val is None:
-            if tb is None:
-                raise typ
-            val = typ()
-        if tb is not None:
-            val = val.with_traceback(tb)
-        raise val
-
-    def close(self):
-        """Raise GeneratorExit inside coroutine.
-        """
-        try:
-            self.throw(GeneratorExit)
-        except (GeneratorExit, StopIteration):
-            pass
-        else:
-            raise RuntimeError("coroutine ignored GeneratorExit")
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Coroutine:
-            return _check_methods(C, '__await__', 'send', 'throw', 'close')
-        return NotImplemented
-
-
-Coroutine.register(coroutine)
-
-
-class AsyncIterable(metaclass=ABCMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __aiter__(self):
-        return AsyncIterator()
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is AsyncIterable:
-            return _check_methods(C, "__aiter__")
-        return NotImplemented
-
+ 
+
+class Coroutine(Awaitable): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def send(self, value): 
+        """Send a value into the coroutine. 
+        Return next yielded value or raise StopIteration. 
+        """ 
+        raise StopIteration 
+ 
+    @abstractmethod 
+    def throw(self, typ, val=None, tb=None): 
+        """Raise an exception in the coroutine. 
+        Return next yielded value or raise StopIteration. 
+        """ 
+        if val is None: 
+            if tb is None: 
+                raise typ 
+            val = typ() 
+        if tb is not None: 
+            val = val.with_traceback(tb) 
+        raise val 
+ 
+    def close(self): 
+        """Raise GeneratorExit inside coroutine. 
+        """ 
+        try: 
+            self.throw(GeneratorExit) 
+        except (GeneratorExit, StopIteration): 
+            pass 
+        else: 
+            raise RuntimeError("coroutine ignored GeneratorExit") 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Coroutine: 
+            return _check_methods(C, '__await__', 'send', 'throw', 'close') 
+        return NotImplemented 
+ 
+ 
+Coroutine.register(coroutine) 
+ 
+ 
+class AsyncIterable(metaclass=ABCMeta): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __aiter__(self): 
+        return AsyncIterator() 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is AsyncIterable: 
+            return _check_methods(C, "__aiter__") 
+        return NotImplemented 
+ 
     __class_getitem__ = classmethod(GenericAlias)
-
-
-class AsyncIterator(AsyncIterable):
-
-    __slots__ = ()
-
-    @abstractmethod
-    async def __anext__(self):
-        """Return the next item or raise StopAsyncIteration when exhausted."""
-        raise StopAsyncIteration
-
-    def __aiter__(self):
-        return self
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is AsyncIterator:
-            return _check_methods(C, "__anext__", "__aiter__")
-        return NotImplemented
-
-
-class AsyncGenerator(AsyncIterator):
-
-    __slots__ = ()
-
-    async def __anext__(self):
-        """Return the next item from the asynchronous generator.
-        When exhausted, raise StopAsyncIteration.
-        """
-        return await self.asend(None)
-
-    @abstractmethod
-    async def asend(self, value):
-        """Send a value into the asynchronous generator.
-        Return next yielded value or raise StopAsyncIteration.
-        """
-        raise StopAsyncIteration
-
-    @abstractmethod
-    async def athrow(self, typ, val=None, tb=None):
-        """Raise an exception in the asynchronous generator.
-        Return next yielded value or raise StopAsyncIteration.
-        """
-        if val is None:
-            if tb is None:
-                raise typ
-            val = typ()
-        if tb is not None:
-            val = val.with_traceback(tb)
-        raise val
-
-    async def aclose(self):
-        """Raise GeneratorExit inside coroutine.
-        """
-        try:
-            await self.athrow(GeneratorExit)
-        except (GeneratorExit, StopAsyncIteration):
-            pass
-        else:
-            raise RuntimeError("asynchronous generator ignored GeneratorExit")
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is AsyncGenerator:
-            return _check_methods(C, '__aiter__', '__anext__',
-                                  'asend', 'athrow', 'aclose')
-        return NotImplemented
-
-
-AsyncGenerator.register(async_generator)
-
-
-class Iterable(metaclass=ABCMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __iter__(self):
-        while False:
-            yield None
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Iterable:
-            return _check_methods(C, "__iter__")
-        return NotImplemented
-
+ 
+
+class AsyncIterator(AsyncIterable): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    async def __anext__(self): 
+        """Return the next item or raise StopAsyncIteration when exhausted.""" 
+        raise StopAsyncIteration 
+ 
+    def __aiter__(self): 
+        return self 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is AsyncIterator: 
+            return _check_methods(C, "__anext__", "__aiter__") 
+        return NotImplemented 
+ 
+ 
+class AsyncGenerator(AsyncIterator): 
+ 
+    __slots__ = () 
+ 
+    async def __anext__(self): 
+        """Return the next item from the asynchronous generator. 
+        When exhausted, raise StopAsyncIteration. 
+        """ 
+        return await self.asend(None) 
+ 
+    @abstractmethod 
+    async def asend(self, value): 
+        """Send a value into the asynchronous generator. 
+        Return next yielded value or raise StopAsyncIteration. 
+        """ 
+        raise StopAsyncIteration 
+ 
+    @abstractmethod 
+    async def athrow(self, typ, val=None, tb=None): 
+        """Raise an exception in the asynchronous generator. 
+        Return next yielded value or raise StopAsyncIteration. 
+        """ 
+        if val is None: 
+            if tb is None: 
+                raise typ 
+            val = typ() 
+        if tb is not None: 
+            val = val.with_traceback(tb) 
+        raise val 
+ 
+    async def aclose(self): 
+        """Raise GeneratorExit inside coroutine. 
+        """ 
+        try: 
+            await self.athrow(GeneratorExit) 
+        except (GeneratorExit, StopAsyncIteration): 
+            pass 
+        else: 
+            raise RuntimeError("asynchronous generator ignored GeneratorExit") 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is AsyncGenerator: 
+            return _check_methods(C, '__aiter__', '__anext__', 
+                                  'asend', 'athrow', 'aclose') 
+        return NotImplemented 
+ 
+ 
+AsyncGenerator.register(async_generator) 
+ 
+ 
+class Iterable(metaclass=ABCMeta): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __iter__(self): 
+        while False: 
+            yield None 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Iterable: 
+            return _check_methods(C, "__iter__") 
+        return NotImplemented 
+ 
     __class_getitem__ = classmethod(GenericAlias)
-
-
-class Iterator(Iterable):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __next__(self):
-        'Return the next item from the iterator. When exhausted, raise StopIteration'
-        raise StopIteration
-
-    def __iter__(self):
-        return self
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Iterator:
-            return _check_methods(C, '__iter__', '__next__')
-        return NotImplemented
-
-
-Iterator.register(bytes_iterator)
-Iterator.register(bytearray_iterator)
-#Iterator.register(callable_iterator)
-Iterator.register(dict_keyiterator)
-Iterator.register(dict_valueiterator)
-Iterator.register(dict_itemiterator)
-Iterator.register(list_iterator)
-Iterator.register(list_reverseiterator)
-Iterator.register(range_iterator)
-Iterator.register(longrange_iterator)
-Iterator.register(set_iterator)
-Iterator.register(str_iterator)
-Iterator.register(tuple_iterator)
-Iterator.register(zip_iterator)
-
-
-class Reversible(Iterable):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __reversed__(self):
-        while False:
-            yield None
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Reversible:
-            return _check_methods(C, "__reversed__", "__iter__")
-        return NotImplemented
-
-
-class Generator(Iterator):
-
-    __slots__ = ()
-
-    def __next__(self):
-        """Return the next item from the generator.
-        When exhausted, raise StopIteration.
-        """
-        return self.send(None)
-
-    @abstractmethod
-    def send(self, value):
-        """Send a value into the generator.
-        Return next yielded value or raise StopIteration.
-        """
-        raise StopIteration
-
-    @abstractmethod
-    def throw(self, typ, val=None, tb=None):
-        """Raise an exception in the generator.
-        Return next yielded value or raise StopIteration.
-        """
-        if val is None:
-            if tb is None:
-                raise typ
-            val = typ()
-        if tb is not None:
-            val = val.with_traceback(tb)
-        raise val
-
-    def close(self):
-        """Raise GeneratorExit inside generator.
-        """
-        try:
-            self.throw(GeneratorExit)
-        except (GeneratorExit, StopIteration):
-            pass
-        else:
-            raise RuntimeError("generator ignored GeneratorExit")
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Generator:
-            return _check_methods(C, '__iter__', '__next__',
-                                  'send', 'throw', 'close')
-        return NotImplemented
-
-
-Generator.register(generator)
-
-
-class Sized(metaclass=ABCMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __len__(self):
-        return 0
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Sized:
-            return _check_methods(C, "__len__")
-        return NotImplemented
-
-
-class Container(metaclass=ABCMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __contains__(self, x):
-        return False
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Container:
-            return _check_methods(C, "__contains__")
-        return NotImplemented
-
+ 
+
+class Iterator(Iterable): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __next__(self): 
+        'Return the next item from the iterator. When exhausted, raise StopIteration' 
+        raise StopIteration 
+ 
+    def __iter__(self): 
+        return self 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Iterator: 
+            return _check_methods(C, '__iter__', '__next__') 
+        return NotImplemented 
+ 
+
+Iterator.register(bytes_iterator) 
+Iterator.register(bytearray_iterator) 
+#Iterator.register(callable_iterator) 
+Iterator.register(dict_keyiterator) 
+Iterator.register(dict_valueiterator) 
+Iterator.register(dict_itemiterator) 
+Iterator.register(list_iterator) 
+Iterator.register(list_reverseiterator) 
+Iterator.register(range_iterator) 
+Iterator.register(longrange_iterator) 
+Iterator.register(set_iterator) 
+Iterator.register(str_iterator) 
+Iterator.register(tuple_iterator) 
+Iterator.register(zip_iterator) 
+ 
+ 
+class Reversible(Iterable): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __reversed__(self): 
+        while False: 
+            yield None 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Reversible: 
+            return _check_methods(C, "__reversed__", "__iter__") 
+        return NotImplemented 
+ 
+ 
+class Generator(Iterator): 
+ 
+    __slots__ = () 
+ 
+    def __next__(self): 
+        """Return the next item from the generator. 
+        When exhausted, raise StopIteration. 
+        """ 
+        return self.send(None) 
+ 
+    @abstractmethod 
+    def send(self, value): 
+        """Send a value into the generator. 
+        Return next yielded value or raise StopIteration. 
+        """ 
+        raise StopIteration 
+ 
+    @abstractmethod 
+    def throw(self, typ, val=None, tb=None): 
+        """Raise an exception in the generator. 
+        Return next yielded value or raise StopIteration. 
+        """ 
+        if val is None: 
+            if tb is None: 
+                raise typ 
+            val = typ() 
+        if tb is not None: 
+            val = val.with_traceback(tb) 
+        raise val 
+ 
+    def close(self): 
+        """Raise GeneratorExit inside generator. 
+        """ 
+        try: 
+            self.throw(GeneratorExit) 
+        except (GeneratorExit, StopIteration): 
+            pass 
+        else: 
+            raise RuntimeError("generator ignored GeneratorExit") 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Generator: 
+            return _check_methods(C, '__iter__', '__next__', 
+                                  'send', 'throw', 'close') 
+        return NotImplemented 
+ 
+
+Generator.register(generator) 
+ 
+ 
+class Sized(metaclass=ABCMeta): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __len__(self): 
+        return 0 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Sized: 
+            return _check_methods(C, "__len__") 
+        return NotImplemented 
+ 
+ 
+class Container(metaclass=ABCMeta): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __contains__(self, x): 
+        return False 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Container: 
+            return _check_methods(C, "__contains__") 
+        return NotImplemented 
+ 
     __class_getitem__ = classmethod(GenericAlias)
 
 
-class Collection(Sized, Iterable, Container):
-
-    __slots__ = ()
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Collection:
-            return _check_methods(C,  "__len__", "__iter__", "__contains__")
-        return NotImplemented
-
+class Collection(Sized, Iterable, Container): 
+ 
+    __slots__ = () 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Collection: 
+            return _check_methods(C,  "__len__", "__iter__", "__contains__") 
+        return NotImplemented 
+ 
 
 class _CallableGenericAlias(GenericAlias):
     """ Represent `Callable[argtypes, resulttype]`.
@@ -493,449 +493,449 @@ def _type_repr(obj):
     return repr(obj)
 
 
-class Callable(metaclass=ABCMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __call__(self, *args, **kwds):
-        return False
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is Callable:
-            return _check_methods(C, "__call__")
-        return NotImplemented
-
+class Callable(metaclass=ABCMeta): 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __call__(self, *args, **kwds): 
+        return False 
+ 
+    @classmethod 
+    def __subclasshook__(cls, C): 
+        if cls is Callable: 
+            return _check_methods(C, "__call__") 
+        return NotImplemented 
+ 
     __class_getitem__ = classmethod(_CallableGenericAlias)
-
-
-### SETS ###
-
-
-class Set(Collection):
-
-    """A set is a finite, iterable container.
-
-    This class provides concrete generic implementations of all
-    methods except for __contains__, __iter__ and __len__.
-
-    To override the comparisons (presumably for speed, as the
-    semantics are fixed), redefine __le__ and __ge__,
-    then the other operations will automatically follow suit.
-    """
-
-    __slots__ = ()
-
-    def __le__(self, other):
-        if not isinstance(other, Set):
-            return NotImplemented
-        if len(self) > len(other):
-            return False
-        for elem in self:
-            if elem not in other:
-                return False
-        return True
-
-    def __lt__(self, other):
-        if not isinstance(other, Set):
-            return NotImplemented
-        return len(self) < len(other) and self.__le__(other)
-
-    def __gt__(self, other):
-        if not isinstance(other, Set):
-            return NotImplemented
-        return len(self) > len(other) and self.__ge__(other)
-
-    def __ge__(self, other):
-        if not isinstance(other, Set):
-            return NotImplemented
-        if len(self) < len(other):
-            return False
-        for elem in other:
-            if elem not in self:
-                return False
-        return True
-
-    def __eq__(self, other):
-        if not isinstance(other, Set):
-            return NotImplemented
-        return len(self) == len(other) and self.__le__(other)
-
-    @classmethod
-    def _from_iterable(cls, it):
-        '''Construct an instance of the class from any iterable input.
-
-        Must override this method if the class constructor signature
-        does not accept an iterable for an input.
-        '''
-        return cls(it)
-
-    def __and__(self, other):
-        if not isinstance(other, Iterable):
-            return NotImplemented
-        return self._from_iterable(value for value in other if value in self)
-
-    __rand__ = __and__
-
-    def isdisjoint(self, other):
-        'Return True if two sets have a null intersection.'
-        for value in other:
-            if value in self:
-                return False
-        return True
-
-    def __or__(self, other):
-        if not isinstance(other, Iterable):
-            return NotImplemented
-        chain = (e for s in (self, other) for e in s)
-        return self._from_iterable(chain)
-
-    __ror__ = __or__
-
-    def __sub__(self, other):
-        if not isinstance(other, Set):
-            if not isinstance(other, Iterable):
-                return NotImplemented
-            other = self._from_iterable(other)
-        return self._from_iterable(value for value in self
-                                   if value not in other)
-
-    def __rsub__(self, other):
-        if not isinstance(other, Set):
-            if not isinstance(other, Iterable):
-                return NotImplemented
-            other = self._from_iterable(other)
-        return self._from_iterable(value for value in other
-                                   if value not in self)
-
-    def __xor__(self, other):
-        if not isinstance(other, Set):
-            if not isinstance(other, Iterable):
-                return NotImplemented
-            other = self._from_iterable(other)
-        return (self - other) | (other - self)
-
-    __rxor__ = __xor__
-
-    def _hash(self):
-        """Compute the hash value of a set.
-
-        Note that we don't define __hash__: not all sets are hashable.
-        But if you define a hashable set type, its __hash__ should
-        call this function.
-
-        This must be compatible __eq__.
-
-        All sets ought to compare equal if they contain the same
-        elements, regardless of how they are implemented, and
-        regardless of the order of the elements; so there's not much
-        freedom for __eq__ or __hash__.  We match the algorithm used
-        by the built-in frozenset type.
-        """
-        MAX = sys.maxsize
-        MASK = 2 * MAX + 1
-        n = len(self)
-        h = 1927868237 * (n + 1)
-        h &= MASK
-        for x in self:
-            hx = hash(x)
-            h ^= (hx ^ (hx << 16) ^ 89869747)  * 3644798167
-            h &= MASK
+ 
+
+### SETS ### 
+ 
+ 
+class Set(Collection): 
+ 
+    """A set is a finite, iterable container. 
+ 
+    This class provides concrete generic implementations of all 
+    methods except for __contains__, __iter__ and __len__. 
+ 
+    To override the comparisons (presumably for speed, as the 
+    semantics are fixed), redefine __le__ and __ge__, 
+    then the other operations will automatically follow suit. 
+    """ 
+ 
+    __slots__ = () 
+ 
+    def __le__(self, other): 
+        if not isinstance(other, Set): 
+            return NotImplemented 
+        if len(self) > len(other): 
+            return False 
+        for elem in self: 
+            if elem not in other: 
+                return False 
+        return True 
+ 
+    def __lt__(self, other): 
+        if not isinstance(other, Set): 
+            return NotImplemented 
+        return len(self) < len(other) and self.__le__(other) 
+ 
+    def __gt__(self, other): 
+        if not isinstance(other, Set): 
+            return NotImplemented 
+        return len(self) > len(other) and self.__ge__(other) 
+ 
+    def __ge__(self, other): 
+        if not isinstance(other, Set): 
+            return NotImplemented 
+        if len(self) < len(other): 
+            return False 
+        for elem in other: 
+            if elem not in self: 
+                return False 
+        return True 
+ 
+    def __eq__(self, other): 
+        if not isinstance(other, Set): 
+            return NotImplemented 
+        return len(self) == len(other) and self.__le__(other) 
+ 
+    @classmethod 
+    def _from_iterable(cls, it): 
+        '''Construct an instance of the class from any iterable input. 
+ 
+        Must override this method if the class constructor signature 
+        does not accept an iterable for an input. 
+        ''' 
+        return cls(it) 
+ 
+    def __and__(self, other): 
+        if not isinstance(other, Iterable): 
+            return NotImplemented 
+        return self._from_iterable(value for value in other if value in self) 
+ 
+    __rand__ = __and__ 
+ 
+    def isdisjoint(self, other): 
+        'Return True if two sets have a null intersection.' 
+        for value in other: 
+            if value in self: 
+                return False 
+        return True 
+ 
+    def __or__(self, other): 
+        if not isinstance(other, Iterable): 
+            return NotImplemented 
+        chain = (e for s in (self, other) for e in s) 
+        return self._from_iterable(chain) 
+ 
+    __ror__ = __or__ 
+ 
+    def __sub__(self, other): 
+        if not isinstance(other, Set): 
+            if not isinstance(other, Iterable): 
+                return NotImplemented 
+            other = self._from_iterable(other) 
+        return self._from_iterable(value for value in self 
+                                   if value not in other) 
+ 
+    def __rsub__(self, other): 
+        if not isinstance(other, Set): 
+            if not isinstance(other, Iterable): 
+                return NotImplemented 
+            other = self._from_iterable(other) 
+        return self._from_iterable(value for value in other 
+                                   if value not in self) 
+ 
+    def __xor__(self, other): 
+        if not isinstance(other, Set): 
+            if not isinstance(other, Iterable): 
+                return NotImplemented 
+            other = self._from_iterable(other) 
+        return (self - other) | (other - self) 
+ 
+    __rxor__ = __xor__ 
+ 
+    def _hash(self): 
+        """Compute the hash value of a set. 
+ 
+        Note that we don't define __hash__: not all sets are hashable. 
+        But if you define a hashable set type, its __hash__ should 
+        call this function. 
+ 
+        This must be compatible __eq__. 
+ 
+        All sets ought to compare equal if they contain the same 
+        elements, regardless of how they are implemented, and 
+        regardless of the order of the elements; so there's not much 
+        freedom for __eq__ or __hash__.  We match the algorithm used 
+        by the built-in frozenset type. 
+        """ 
+        MAX = sys.maxsize 
+        MASK = 2 * MAX + 1 
+        n = len(self) 
+        h = 1927868237 * (n + 1) 
+        h &= MASK 
+        for x in self: 
+            hx = hash(x) 
+            h ^= (hx ^ (hx << 16) ^ 89869747)  * 3644798167 
+            h &= MASK 
         h ^= (h >> 11) ^ (h >> 25)
-        h = h * 69069 + 907133923
-        h &= MASK
-        if h > MAX:
-            h -= MASK + 1
-        if h == -1:
-            h = 590923713
-        return h
-
-
-Set.register(frozenset)
-
-
-class MutableSet(Set):
-    """A mutable set is a finite, iterable container.
-
-    This class provides concrete generic implementations of all
-    methods except for __contains__, __iter__, __len__,
-    add(), and discard().
-
-    To override the comparisons (presumably for speed, as the
-    semantics are fixed), all you have to do is redefine __le__ and
-    then the other operations will automatically follow suit.
-    """
-
-    __slots__ = ()
-
-    @abstractmethod
-    def add(self, value):
-        """Add an element."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def discard(self, value):
-        """Remove an element.  Do not raise an exception if absent."""
-        raise NotImplementedError
-
-    def remove(self, value):
-        """Remove an element. If not a member, raise a KeyError."""
-        if value not in self:
-            raise KeyError(value)
-        self.discard(value)
-
-    def pop(self):
-        """Return the popped value.  Raise KeyError if empty."""
-        it = iter(self)
-        try:
-            value = next(it)
-        except StopIteration:
-            raise KeyError from None
-        self.discard(value)
-        return value
-
-    def clear(self):
-        """This is slow (creates N new iterators!) but effective."""
-        try:
-            while True:
-                self.pop()
-        except KeyError:
-            pass
-
-    def __ior__(self, it):
-        for value in it:
-            self.add(value)
-        return self
-
-    def __iand__(self, it):
-        for value in (self - it):
-            self.discard(value)
-        return self
-
-    def __ixor__(self, it):
-        if it is self:
-            self.clear()
-        else:
-            if not isinstance(it, Set):
-                it = self._from_iterable(it)
-            for value in it:
-                if value in self:
-                    self.discard(value)
-                else:
-                    self.add(value)
-        return self
-
-    def __isub__(self, it):
-        if it is self:
-            self.clear()
-        else:
-            for value in it:
-                self.discard(value)
-        return self
-
-
-MutableSet.register(set)
-
-
-### MAPPINGS ###
-
-
-class Mapping(Collection):
-
-    __slots__ = ()
-
-    """A Mapping is a generic container for associating key/value
-    pairs.
-
-    This class provides concrete generic implementations of all
-    methods except for __getitem__, __iter__, and __len__.
-
-    """
-
-    @abstractmethod
-    def __getitem__(self, key):
-        raise KeyError
-
-    def get(self, key, default=None):
-        'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.'
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def __contains__(self, key):
-        try:
-            self[key]
-        except KeyError:
-            return False
-        else:
-            return True
-
-    def keys(self):
-        "D.keys() -> a set-like object providing a view on D's keys"
-        return KeysView(self)
-
-    def items(self):
-        "D.items() -> a set-like object providing a view on D's items"
-        return ItemsView(self)
-
-    def values(self):
-        "D.values() -> an object providing a view on D's values"
-        return ValuesView(self)
-
-    def __eq__(self, other):
-        if not isinstance(other, Mapping):
-            return NotImplemented
-        return dict(self.items()) == dict(other.items())
-
-    __reversed__ = None
-
-
-Mapping.register(mappingproxy)
-
-
-class MappingView(Sized):
-
-    __slots__ = '_mapping',
-
-    def __init__(self, mapping):
-        self._mapping = mapping
-
-    def __len__(self):
-        return len(self._mapping)
-
-    def __repr__(self):
-        return '{0.__class__.__name__}({0._mapping!r})'.format(self)
-
+        h = h * 69069 + 907133923 
+        h &= MASK 
+        if h > MAX: 
+            h -= MASK + 1 
+        if h == -1: 
+            h = 590923713 
+        return h 
+ 
+
+Set.register(frozenset) 
+ 
+ 
+class MutableSet(Set): 
+    """A mutable set is a finite, iterable container. 
+ 
+    This class provides concrete generic implementations of all 
+    methods except for __contains__, __iter__, __len__, 
+    add(), and discard(). 
+ 
+    To override the comparisons (presumably for speed, as the 
+    semantics are fixed), all you have to do is redefine __le__ and 
+    then the other operations will automatically follow suit. 
+    """ 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def add(self, value): 
+        """Add an element.""" 
+        raise NotImplementedError 
+ 
+    @abstractmethod 
+    def discard(self, value): 
+        """Remove an element.  Do not raise an exception if absent.""" 
+        raise NotImplementedError 
+ 
+    def remove(self, value): 
+        """Remove an element. If not a member, raise a KeyError.""" 
+        if value not in self: 
+            raise KeyError(value) 
+        self.discard(value) 
+ 
+    def pop(self): 
+        """Return the popped value.  Raise KeyError if empty.""" 
+        it = iter(self) 
+        try: 
+            value = next(it) 
+        except StopIteration: 
+            raise KeyError from None 
+        self.discard(value) 
+        return value 
+ 
+    def clear(self): 
+        """This is slow (creates N new iterators!) but effective.""" 
+        try: 
+            while True: 
+                self.pop() 
+        except KeyError: 
+            pass 
+ 
+    def __ior__(self, it): 
+        for value in it: 
+            self.add(value) 
+        return self 
+ 
+    def __iand__(self, it): 
+        for value in (self - it): 
+            self.discard(value) 
+        return self 
+ 
+    def __ixor__(self, it): 
+        if it is self: 
+            self.clear() 
+        else: 
+            if not isinstance(it, Set): 
+                it = self._from_iterable(it) 
+            for value in it: 
+                if value in self: 
+                    self.discard(value) 
+                else: 
+                    self.add(value) 
+        return self 
+ 
+    def __isub__(self, it): 
+        if it is self: 
+            self.clear() 
+        else: 
+            for value in it: 
+                self.discard(value) 
+        return self 
+ 
+
+MutableSet.register(set) 
+ 
+ 
+### MAPPINGS ### 
+ 
+ 
+class Mapping(Collection): 
+ 
+    __slots__ = () 
+ 
+    """A Mapping is a generic container for associating key/value 
+    pairs. 
+ 
+    This class provides concrete generic implementations of all 
+    methods except for __getitem__, __iter__, and __len__. 
+ 
+    """ 
+ 
+    @abstractmethod 
+    def __getitem__(self, key): 
+        raise KeyError 
+ 
+    def get(self, key, default=None): 
+        'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.' 
+        try: 
+            return self[key] 
+        except KeyError: 
+            return default 
+ 
+    def __contains__(self, key): 
+        try: 
+            self[key] 
+        except KeyError: 
+            return False 
+        else: 
+            return True 
+ 
+    def keys(self): 
+        "D.keys() -> a set-like object providing a view on D's keys" 
+        return KeysView(self) 
+ 
+    def items(self): 
+        "D.items() -> a set-like object providing a view on D's items" 
+        return ItemsView(self) 
+ 
+    def values(self): 
+        "D.values() -> an object providing a view on D's values" 
+        return ValuesView(self) 
+ 
+    def __eq__(self, other): 
+        if not isinstance(other, Mapping): 
+            return NotImplemented 
+        return dict(self.items()) == dict(other.items()) 
+ 
+    __reversed__ = None 
+ 
+
+Mapping.register(mappingproxy) 
+ 
+ 
+class MappingView(Sized): 
+ 
+    __slots__ = '_mapping', 
+ 
+    def __init__(self, mapping): 
+        self._mapping = mapping 
+ 
+    def __len__(self): 
+        return len(self._mapping) 
+ 
+    def __repr__(self): 
+        return '{0.__class__.__name__}({0._mapping!r})'.format(self) 
+ 
     __class_getitem__ = classmethod(GenericAlias)
-
-
-class KeysView(MappingView, Set):
-
-    __slots__ = ()
-
-    @classmethod
-    def _from_iterable(self, it):
-        return set(it)
-
-    def __contains__(self, key):
-        return key in self._mapping
-
-    def __iter__(self):
-        yield from self._mapping
-
-
-KeysView.register(dict_keys)
-
-
-class ItemsView(MappingView, Set):
-
-    __slots__ = ()
-
-    @classmethod
-    def _from_iterable(self, it):
-        return set(it)
-
-    def __contains__(self, item):
-        key, value = item
-        try:
-            v = self._mapping[key]
-        except KeyError:
-            return False
-        else:
-            return v is value or v == value
-
-    def __iter__(self):
-        for key in self._mapping:
-            yield (key, self._mapping[key])
-
-
-ItemsView.register(dict_items)
-
-
-class ValuesView(MappingView, Collection):
-
-    __slots__ = ()
-
-    def __contains__(self, value):
-        for key in self._mapping:
-            v = self._mapping[key]
-            if v is value or v == value:
-                return True
-        return False
-
-    def __iter__(self):
-        for key in self._mapping:
-            yield self._mapping[key]
-
-
-ValuesView.register(dict_values)
-
-
-class MutableMapping(Mapping):
-
-    __slots__ = ()
-
-    """A MutableMapping is a generic container for associating
-    key/value pairs.
-
-    This class provides concrete generic implementations of all
-    methods except for __getitem__, __setitem__, __delitem__,
-    __iter__, and __len__.
-
-    """
-
-    @abstractmethod
-    def __setitem__(self, key, value):
-        raise KeyError
-
-    @abstractmethod
-    def __delitem__(self, key):
-        raise KeyError
-
-    __marker = object()
-
-    def pop(self, key, default=__marker):
-        '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
-          If key is not found, d is returned if given, otherwise KeyError is raised.
-        '''
-        try:
-            value = self[key]
-        except KeyError:
-            if default is self.__marker:
-                raise
-            return default
-        else:
-            del self[key]
-            return value
-
-    def popitem(self):
-        '''D.popitem() -> (k, v), remove and return some (key, value) pair
-           as a 2-tuple; but raise KeyError if D is empty.
-        '''
-        try:
-            key = next(iter(self))
-        except StopIteration:
-            raise KeyError from None
-        value = self[key]
-        del self[key]
-        return key, value
-
-    def clear(self):
-        'D.clear() -> None.  Remove all items from D.'
-        try:
-            while True:
-                self.popitem()
-        except KeyError:
-            pass
-
+ 
+
+class KeysView(MappingView, Set): 
+ 
+    __slots__ = () 
+ 
+    @classmethod 
+    def _from_iterable(self, it): 
+        return set(it) 
+ 
+    def __contains__(self, key): 
+        return key in self._mapping 
+ 
+    def __iter__(self): 
+        yield from self._mapping 
+ 
+
+KeysView.register(dict_keys) 
+ 
+ 
+class ItemsView(MappingView, Set): 
+ 
+    __slots__ = () 
+ 
+    @classmethod 
+    def _from_iterable(self, it): 
+        return set(it) 
+ 
+    def __contains__(self, item): 
+        key, value = item 
+        try: 
+            v = self._mapping[key] 
+        except KeyError: 
+            return False 
+        else: 
+            return v is value or v == value 
+ 
+    def __iter__(self): 
+        for key in self._mapping: 
+            yield (key, self._mapping[key]) 
+ 
+
+ItemsView.register(dict_items) 
+ 
+ 
+class ValuesView(MappingView, Collection): 
+ 
+    __slots__ = () 
+ 
+    def __contains__(self, value): 
+        for key in self._mapping: 
+            v = self._mapping[key] 
+            if v is value or v == value: 
+                return True 
+        return False 
+ 
+    def __iter__(self): 
+        for key in self._mapping: 
+            yield self._mapping[key] 
+ 
+
+ValuesView.register(dict_values) 
+ 
+ 
+class MutableMapping(Mapping): 
+ 
+    __slots__ = () 
+ 
+    """A MutableMapping is a generic container for associating 
+    key/value pairs. 
+ 
+    This class provides concrete generic implementations of all 
+    methods except for __getitem__, __setitem__, __delitem__, 
+    __iter__, and __len__. 
+ 
+    """ 
+ 
+    @abstractmethod 
+    def __setitem__(self, key, value): 
+        raise KeyError 
+ 
+    @abstractmethod 
+    def __delitem__(self, key): 
+        raise KeyError 
+ 
+    __marker = object() 
+ 
+    def pop(self, key, default=__marker): 
+        '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value. 
+          If key is not found, d is returned if given, otherwise KeyError is raised. 
+        ''' 
+        try: 
+            value = self[key] 
+        except KeyError: 
+            if default is self.__marker: 
+                raise 
+            return default 
+        else: 
+            del self[key] 
+            return value 
+ 
+    def popitem(self): 
+        '''D.popitem() -> (k, v), remove and return some (key, value) pair 
+           as a 2-tuple; but raise KeyError if D is empty. 
+        ''' 
+        try: 
+            key = next(iter(self)) 
+        except StopIteration: 
+            raise KeyError from None 
+        value = self[key] 
+        del self[key] 
+        return key, value 
+ 
+    def clear(self): 
+        'D.clear() -> None.  Remove all items from D.' 
+        try: 
+            while True: 
+                self.popitem() 
+        except KeyError: 
+            pass 
+ 
     def update(self, other=(), /, **kwds):
-        ''' D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
-            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
-            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
-            In either case, this is followed by: for k, v in F.items(): D[k] = v
-        '''
+        ''' D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F. 
+            If E present and has a .keys() method, does:     for k in E: D[k] = E[k] 
+            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v 
+            In either case, this is followed by: for k, v in F.items(): D[k] = v 
+        ''' 
         if isinstance(other, Mapping):
             for key in other:
                 self[key] = other[key]
@@ -945,172 +945,172 @@ class MutableMapping(Mapping):
         else:
             for key, value in other:
                 self[key] = value
-        for key, value in kwds.items():
-            self[key] = value
-
-    def setdefault(self, key, default=None):
-        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'
-        try:
-            return self[key]
-        except KeyError:
-            self[key] = default
-        return default
-
-
-MutableMapping.register(dict)
-
-
-### SEQUENCES ###
-
-
-class Sequence(Reversible, Collection):
-
-    """All the operations on a read-only sequence.
-
-    Concrete subclasses must override __new__ or __init__,
-    __getitem__, and __len__.
-    """
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __getitem__(self, index):
-        raise IndexError
-
-    def __iter__(self):
-        i = 0
-        try:
-            while True:
-                v = self[i]
-                yield v
-                i += 1
-        except IndexError:
-            return
-
-    def __contains__(self, value):
-        for v in self:
-            if v is value or v == value:
-                return True
-        return False
-
-    def __reversed__(self):
-        for i in reversed(range(len(self))):
-            yield self[i]
-
-    def index(self, value, start=0, stop=None):
-        '''S.index(value, [start, [stop]]) -> integer -- return first index of value.
-           Raises ValueError if the value is not present.
-
-           Supporting start and stop arguments is optional, but
-           recommended.
-        '''
-        if start is not None and start < 0:
-            start = max(len(self) + start, 0)
-        if stop is not None and stop < 0:
-            stop += len(self)
-
-        i = start
-        while stop is None or i < stop:
-            try:
-                v = self[i]
-                if v is value or v == value:
-                    return i
-            except IndexError:
-                break
-            i += 1
-        raise ValueError
-
-    def count(self, value):
-        'S.count(value) -> integer -- return number of occurrences of value'
-        return sum(1 for v in self if v is value or v == value)
-
-
-Sequence.register(tuple)
-Sequence.register(str)
-Sequence.register(range)
-Sequence.register(memoryview)
-
-
-class ByteString(Sequence):
-
-    """This unifies bytes and bytearray.
-
-    XXX Should add all their methods.
-    """
-
-    __slots__ = ()
-
-ByteString.register(bytes)
-ByteString.register(bytearray)
-
-
-class MutableSequence(Sequence):
-
-    __slots__ = ()
-
-    """All the operations on a read-write sequence.
-
-    Concrete subclasses must provide __new__ or __init__,
-    __getitem__, __setitem__, __delitem__, __len__, and insert().
-
-    """
-
-    @abstractmethod
-    def __setitem__(self, index, value):
-        raise IndexError
-
-    @abstractmethod
-    def __delitem__(self, index):
-        raise IndexError
-
-    @abstractmethod
-    def insert(self, index, value):
-        'S.insert(index, value) -- insert value before index'
-        raise IndexError
-
-    def append(self, value):
-        'S.append(value) -- append value to the end of the sequence'
-        self.insert(len(self), value)
-
-    def clear(self):
-        'S.clear() -> None -- remove all items from S'
-        try:
-            while True:
-                self.pop()
-        except IndexError:
-            pass
-
-    def reverse(self):
-        'S.reverse() -- reverse *IN PLACE*'
-        n = len(self)
-        for i in range(n//2):
-            self[i], self[n-i-1] = self[n-i-1], self[i]
-
-    def extend(self, values):
-        'S.extend(iterable) -- extend sequence by appending elements from the iterable'
+        for key, value in kwds.items(): 
+            self[key] = value 
+ 
+    def setdefault(self, key, default=None): 
+        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D' 
+        try: 
+            return self[key] 
+        except KeyError: 
+            self[key] = default 
+        return default 
+ 
+
+MutableMapping.register(dict) 
+ 
+ 
+### SEQUENCES ### 
+ 
+ 
+class Sequence(Reversible, Collection): 
+ 
+    """All the operations on a read-only sequence. 
+ 
+    Concrete subclasses must override __new__ or __init__, 
+    __getitem__, and __len__. 
+    """ 
+ 
+    __slots__ = () 
+ 
+    @abstractmethod 
+    def __getitem__(self, index): 
+        raise IndexError 
+ 
+    def __iter__(self): 
+        i = 0 
+        try: 
+            while True: 
+                v = self[i] 
+                yield v 
+                i += 1 
+        except IndexError: 
+            return 
+ 
+    def __contains__(self, value): 
+        for v in self: 
+            if v is value or v == value: 
+                return True 
+        return False 
+ 
+    def __reversed__(self): 
+        for i in reversed(range(len(self))): 
+            yield self[i] 
+ 
+    def index(self, value, start=0, stop=None): 
+        '''S.index(value, [start, [stop]]) -> integer -- return first index of value. 
+           Raises ValueError if the value is not present. 
+ 
+           Supporting start and stop arguments is optional, but 
+           recommended. 
+        ''' 
+        if start is not None and start < 0: 
+            start = max(len(self) + start, 0) 
+        if stop is not None and stop < 0: 
+            stop += len(self) 
+ 
+        i = start 
+        while stop is None or i < stop: 
+            try: 
+                v = self[i] 
+                if v is value or v == value: 
+                    return i 
+            except IndexError: 
+                break 
+            i += 1 
+        raise ValueError 
+ 
+    def count(self, value): 
+        'S.count(value) -> integer -- return number of occurrences of value' 
+        return sum(1 for v in self if v is value or v == value) 
+ 
+
+Sequence.register(tuple) 
+Sequence.register(str) 
+Sequence.register(range) 
+Sequence.register(memoryview) 
+ 
+ 
+class ByteString(Sequence): 
+ 
+    """This unifies bytes and bytearray. 
+ 
+    XXX Should add all their methods. 
+    """ 
+ 
+    __slots__ = () 
+ 
+ByteString.register(bytes) 
+ByteString.register(bytearray) 
+ 
+ 
+class MutableSequence(Sequence): 
+ 
+    __slots__ = () 
+ 
+    """All the operations on a read-write sequence. 
+ 
+    Concrete subclasses must provide __new__ or __init__, 
+    __getitem__, __setitem__, __delitem__, __len__, and insert(). 
+ 
+    """ 
+ 
+    @abstractmethod 
+    def __setitem__(self, index, value): 
+        raise IndexError 
+ 
+    @abstractmethod 
+    def __delitem__(self, index): 
+        raise IndexError 
+ 
+    @abstractmethod 
+    def insert(self, index, value): 
+        'S.insert(index, value) -- insert value before index' 
+        raise IndexError 
+ 
+    def append(self, value): 
+        'S.append(value) -- append value to the end of the sequence' 
+        self.insert(len(self), value) 
+ 
+    def clear(self): 
+        'S.clear() -> None -- remove all items from S' 
+        try: 
+            while True: 
+                self.pop() 
+        except IndexError: 
+            pass 
+ 
+    def reverse(self): 
+        'S.reverse() -- reverse *IN PLACE*' 
+        n = len(self) 
+        for i in range(n//2): 
+            self[i], self[n-i-1] = self[n-i-1], self[i] 
+ 
+    def extend(self, values): 
+        'S.extend(iterable) -- extend sequence by appending elements from the iterable' 
         if values is self:
             values = list(values)
-        for v in values:
-            self.append(v)
-
-    def pop(self, index=-1):
-        '''S.pop([index]) -> item -- remove and return item at index (default last).
-           Raise IndexError if list is empty or index is out of range.
-        '''
-        v = self[index]
-        del self[index]
-        return v
-
-    def remove(self, value):
-        '''S.remove(value) -- remove first occurrence of value.
-           Raise ValueError if the value is not present.
-        '''
-        del self[self.index(value)]
-
-    def __iadd__(self, values):
-        self.extend(values)
-        return self
-
-
-MutableSequence.register(list)
-MutableSequence.register(bytearray)  # Multiply inheriting, see ByteString
+        for v in values: 
+            self.append(v) 
+ 
+    def pop(self, index=-1): 
+        '''S.pop([index]) -> item -- remove and return item at index (default last). 
+           Raise IndexError if list is empty or index is out of range. 
+        ''' 
+        v = self[index] 
+        del self[index] 
+        return v 
+ 
+    def remove(self, value): 
+        '''S.remove(value) -- remove first occurrence of value. 
+           Raise ValueError if the value is not present. 
+        ''' 
+        del self[self.index(value)] 
+ 
+    def __iadd__(self, values): 
+        self.extend(values) 
+        return self 
+ 
+
+MutableSequence.register(list) 
+MutableSequence.register(bytearray)  # Multiply inheriting, see ByteString