<h2>Edit File - _collections_abc.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/python3.8/_collections_abc.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;"># Copyright 2007 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.

&quot;&quot;&quot;Abstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
&quot;&quot;&quot;

from abc import ABCMeta, abstractmethod
import sys

__all__ = [&quot;Awaitable&quot;, &quot;Coroutine&quot;,
           &quot;AsyncIterable&quot;, &quot;AsyncIterator&quot;, &quot;AsyncGenerator&quot;,
           &quot;Hashable&quot;, &quot;Iterable&quot;, &quot;Iterator&quot;, &quot;Generator&quot;, &quot;Reversible&quot;,
           &quot;Sized&quot;, &quot;Container&quot;, &quot;Callable&quot;, &quot;Collection&quot;,
           &quot;Set&quot;, &quot;MutableSet&quot;,
           &quot;Mapping&quot;, &quot;MutableMapping&quot;,
           &quot;MappingView&quot;, &quot;KeysView&quot;, &quot;ItemsView&quot;, &quot;ValuesView&quot;,
           &quot;Sequence&quot;, &quot;MutableSequence&quot;,
           &quot;ByteString&quot;,
           ]

# 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__ = &quot;collections.abc&quot;

# 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&#039;&#039;))
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 &lt;&lt; 1000)))
set_iterator = type(iter(set()))
str_iterator = type(iter(&quot;&quot;))
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, &quot;__hash__&quot;)
        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, &quot;__await__&quot;)
        return NotImplemented


class Coroutine(Awaitable):

    __slots__ = ()

    @abstractmethod
    def send(self, value):
        &quot;&quot;&quot;Send a value into the coroutine.
        Return next yielded value or raise StopIteration.
        &quot;&quot;&quot;
        raise StopIteration

    @abstractmethod
    def throw(self, typ, val=None, tb=None):
        &quot;&quot;&quot;Raise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        &quot;&quot;&quot;
        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):
        &quot;&quot;&quot;Raise GeneratorExit inside coroutine.
        &quot;&quot;&quot;
        try:
            self.throw(GeneratorExit)
        except (GeneratorExit, StopIteration):
            pass
        else:
            raise RuntimeError(&quot;coroutine ignored GeneratorExit&quot;)

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Coroutine:
            return _check_methods(C, &#039;__await__&#039;, &#039;send&#039;, &#039;throw&#039;, &#039;close&#039;)
        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, &quot;__aiter__&quot;)
        return NotImplemented


class AsyncIterator(AsyncIterable):

    __slots__ = ()

    @abstractmethod
    async def __anext__(self):
        &quot;&quot;&quot;Return the next item or raise StopAsyncIteration when exhausted.&quot;&quot;&quot;
        raise StopAsyncIteration

    def __aiter__(self):
        return self

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncIterator:
            return _check_methods(C, &quot;__anext__&quot;, &quot;__aiter__&quot;)
        return NotImplemented


class AsyncGenerator(AsyncIterator):

    __slots__ = ()

    async def __anext__(self):
        &quot;&quot;&quot;Return the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        &quot;&quot;&quot;
        return await self.asend(None)

    @abstractmethod
    async def asend(self, value):
        &quot;&quot;&quot;Send a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        &quot;&quot;&quot;
        raise StopAsyncIteration

    @abstractmethod
    async def athrow(self, typ, val=None, tb=None):
        &quot;&quot;&quot;Raise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        &quot;&quot;&quot;
        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):
        &quot;&quot;&quot;Raise GeneratorExit inside coroutine.
        &quot;&quot;&quot;
        try:
            await self.athrow(GeneratorExit)
        except (GeneratorExit, StopAsyncIteration):
            pass
        else:
            raise RuntimeError(&quot;asynchronous generator ignored GeneratorExit&quot;)

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AsyncGenerator:
            return _check_methods(C, &#039;__aiter__&#039;, &#039;__anext__&#039;,
                                  &#039;asend&#039;, &#039;athrow&#039;, &#039;aclose&#039;)
        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, &quot;__iter__&quot;)
        return NotImplemented


class Iterator(Iterable):

    __slots__ = ()

    @abstractmethod
    def __next__(self):
        &#039;Return the next item from the iterator. When exhausted, raise StopIteration&#039;
        raise StopIteration

    def __iter__(self):
        return self

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Iterator:
            return _check_methods(C, &#039;__iter__&#039;, &#039;__next__&#039;)
        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, &quot;__reversed__&quot;, &quot;__iter__&quot;)
        return NotImplemented


class Generator(Iterator):

    __slots__ = ()

    def __next__(self):
        &quot;&quot;&quot;Return the next item from the generator.
        When exhausted, raise StopIteration.
        &quot;&quot;&quot;
        return self.send(None)

    @abstractmethod
    def send(self, value):
        &quot;&quot;&quot;Send a value into the generator.
        Return next yielded value or raise StopIteration.
        &quot;&quot;&quot;
        raise StopIteration

    @abstractmethod
    def throw(self, typ, val=None, tb=None):
        &quot;&quot;&quot;Raise an exception in the generator.
        Return next yielded value or raise StopIteration.
        &quot;&quot;&quot;
        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):
        &quot;&quot;&quot;Raise GeneratorExit inside generator.
        &quot;&quot;&quot;
        try:
            self.throw(GeneratorExit)
        except (GeneratorExit, StopIteration):
            pass
        else:
            raise RuntimeError(&quot;generator ignored GeneratorExit&quot;)

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Generator:
            return _check_methods(C, &#039;__iter__&#039;, &#039;__next__&#039;,
                                  &#039;send&#039;, &#039;throw&#039;, &#039;close&#039;)
        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, &quot;__len__&quot;)
        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, &quot;__contains__&quot;)
        return NotImplemented

class Collection(Sized, Iterable, Container):

    __slots__ = ()

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Collection:
            return _check_methods(C,  &quot;__len__&quot;, &quot;__iter__&quot;, &quot;__contains__&quot;)
        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, &quot;__call__&quot;)
        return NotImplemented


### SETS ###


class Set(Collection):

    &quot;&quot;&quot;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.
    &quot;&quot;&quot;

    __slots__ = ()

    def __le__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        if len(self) &gt; 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) &lt; len(other) and self.__le__(other)

    def __gt__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return len(self) &gt; len(other) and self.__ge__(other)

    def __ge__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        if len(self) &lt; 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):
        &#039;&#039;&#039;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.
        &#039;&#039;&#039;
        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):
        &#039;Return True if two sets have a null intersection.&#039;
        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):
        &quot;&quot;&quot;Compute the hash value of a set.

        Note that we don&#039;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&#039;s not much
        freedom for __eq__ or __hash__.  We match the algorithm used
        by the built-in frozenset type.
        &quot;&quot;&quot;
        MAX = sys.maxsize
        MASK = 2 * MAX + 1
        n = len(self)
        h = 1927868237 * (n + 1)
        h &amp;= MASK
        for x in self:
            hx = hash(x)
            h ^= (hx ^ (hx &lt;&lt; 16) ^ 89869747)  * 3644798167
            h &amp;= MASK
        h = h * 69069 + 907133923
        h &amp;= MASK
        if h &gt; MAX:
            h -= MASK + 1
        if h == -1:
            h = 590923713
        return h

Set.register(frozenset)


class MutableSet(Set):
    &quot;&quot;&quot;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.
    &quot;&quot;&quot;

    __slots__ = ()

    @abstractmethod
    def add(self, value):
        &quot;&quot;&quot;Add an element.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def discard(self, value):
        &quot;&quot;&quot;Remove an element.  Do not raise an exception if absent.&quot;&quot;&quot;
        raise NotImplementedError

    def remove(self, value):
        &quot;&quot;&quot;Remove an element. If not a member, raise a KeyError.&quot;&quot;&quot;
        if value not in self:
            raise KeyError(value)
        self.discard(value)

    def pop(self):
        &quot;&quot;&quot;Return the popped value.  Raise KeyError if empty.&quot;&quot;&quot;
        it = iter(self)
        try:
            value = next(it)
        except StopIteration:
            raise KeyError from None
        self.discard(value)
        return value

    def clear(self):
        &quot;&quot;&quot;This is slow (creates N new iterators!) but effective.&quot;&quot;&quot;
        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__ = ()

    &quot;&quot;&quot;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__.

    &quot;&quot;&quot;

    @abstractmethod
    def __getitem__(self, key):
        raise KeyError

    def get(self, key, default=None):
        &#039;D.get(k[,d]) -&gt; D[k] if k in D, else d.  d defaults to None.&#039;
        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):
        &quot;D.keys() -&gt; a set-like object providing a view on D&#039;s keys&quot;
        return KeysView(self)

    def items(self):
        &quot;D.items() -&gt; a set-like object providing a view on D&#039;s items&quot;
        return ItemsView(self)

    def values(self):
        &quot;D.values() -&gt; an object providing a view on D&#039;s values&quot;
        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__ = &#039;_mapping&#039;,

    def __init__(self, mapping):
        self._mapping = mapping

    def __len__(self):
        return len(self._mapping)

    def __repr__(self):
        return &#039;{0.__class__.__name__}({0._mapping!r})&#039;.format(self)


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__ = ()

    &quot;&quot;&quot;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__.

    &quot;&quot;&quot;

    @abstractmethod
    def __setitem__(self, key, value):
        raise KeyError

    @abstractmethod
    def __delitem__(self, key):
        raise KeyError

    __marker = object()

    def pop(self, key, default=__marker):
        &#039;&#039;&#039;D.pop(k[,d]) -&gt; v, remove specified key and return the corresponding value.
          If key is not found, d is returned if given, otherwise KeyError is raised.
        &#039;&#039;&#039;
        try:
            value = self[key]
        except KeyError:
            if default is self.__marker:
                raise
            return default
        else:
            del self[key]
            return value

    def popitem(self):
        &#039;&#039;&#039;D.popitem() -&gt; (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        &#039;&#039;&#039;
        try:
            key = next(iter(self))
        except StopIteration:
            raise KeyError from None
        value = self[key]
        del self[key]
        return key, value

    def clear(self):
        &#039;D.clear() -&gt; None.  Remove all items from D.&#039;
        try:
            while True:
                self.popitem()
        except KeyError:
            pass

    def update(self, other=(), /, **kwds):
        &#039;&#039;&#039; D.update([E, ]**F) -&gt; 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
        &#039;&#039;&#039;
        if isinstance(other, Mapping):
            for key in other:
                self[key] = other[key]
        elif hasattr(other, &quot;keys&quot;):
            for key in other.keys():
                self[key] = other[key]
        else:
            for key, value in other:
                self[key] = value
        for key, value in kwds.items():
            self[key] = value

    def setdefault(self, key, default=None):
        &#039;D.setdefault(k[,d]) -&gt; D.get(k,d), also set D[k]=d if k not in D&#039;
        try:
            return self[key]
        except KeyError:
            self[key] = default
        return default

MutableMapping.register(dict)


### SEQUENCES ###


class Sequence(Reversible, Collection):

    &quot;&quot;&quot;All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    &quot;&quot;&quot;

    __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):
        &#039;&#039;&#039;S.index(value, [start, [stop]]) -&gt; integer -- return first index of value.
           Raises ValueError if the value is not present.

           Supporting start and stop arguments is optional, but
           recommended.
        &#039;&#039;&#039;
        if start is not None and start &lt; 0:
            start = max(len(self) + start, 0)
        if stop is not None and stop &lt; 0:
            stop += len(self)

        i = start
        while stop is None or i &lt; 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):
        &#039;S.count(value) -&gt; integer -- return number of occurrences of value&#039;
        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):

    &quot;&quot;&quot;This unifies bytes and bytearray.

    XXX Should add all their methods.
    &quot;&quot;&quot;

    __slots__ = ()

ByteString.register(bytes)
ByteString.register(bytearray)


class MutableSequence(Sequence):

    __slots__ = ()

    &quot;&quot;&quot;All the operations on a read-write sequence.

    Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().

    &quot;&quot;&quot;

    @abstractmethod
    def __setitem__(self, index, value):
        raise IndexError

    @abstractmethod
    def __delitem__(self, index):
        raise IndexError

    @abstractmethod
    def insert(self, index, value):
        &#039;S.insert(index, value) -- insert value before index&#039;
        raise IndexError

    def append(self, value):
        &#039;S.append(value) -- append value to the end of the sequence&#039;
        self.insert(len(self), value)

    def clear(self):
        &#039;S.clear() -&gt; None -- remove all items from S&#039;
        try:
            while True:
                self.pop()
        except IndexError:
            pass

    def reverse(self):
        &#039;S.reverse() -- reverse *IN PLACE*&#039;
        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):
        &#039;S.extend(iterable) -- extend sequence by appending elements from the iterable&#039;
        if values is self:
            values = list(values)
        for v in values:
            self.append(v)

    def pop(self, index=-1):
        &#039;&#039;&#039;S.pop([index]) -&gt; item -- remove and return item at index (default last).
           Raise IndexError if list is empty or index is out of range.
        &#039;&#039;&#039;
        v = self[index]
        del self[index]
        return v

    def remove(self, value):
        &#039;&#039;&#039;S.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        &#039;&#039;&#039;
        del self[self.index(value)]

    def __iadd__(self, values):
        self.extend(values)
        return self

MutableSequence.register(list)
MutableSequence.register(bytearray)  # Multiply inheriting, see ByteString
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>