from collections.abc import Iterator, MutableSequence, Iterable
class LazyList(MutableSequence):
    def __init__(self, items: Iterable):
        self.generator = iter(items)
        self.items_ = []

    def insert(self, index: int, value) -> None:
        self._next(index)
        self.items_.insert(index, value)

    def _next(self, index):
        if isinstance(index, slice):
            max_index = index.stop
        else:
            max_index = index
        if max_index is None:
            for it in self.generator:
                self.items_.append(it)
        else:
            while len(self.items_) <= max_index:
                try:
                    self.items_.append(next(self.generator))
                except StopIteration:
                    break

    def append(self, value):
        self.items_.append(value)

    def extend(self, values: Iterable) -> None:
        self.items_.extend(values)

    def __getitem__(self, index):
        self._next(index)
        return self.items_[index]

    def __setitem__(self, index, value) -> None:
        self._next(index)
        self.items_[index] = value

    def __delitem__(self, index) -> None:
        self._next(index)
        del self.items_[index]

    def __contains__(self, x) -> bool:
        if x in self.items_:
            return True
        for item in self.generator:
            self.items_.append(item)
            if item == x:
                return True
        return False

    def __len__(self) -> int:
        for x in self.generator:
            self.items_.append(x)
        return len(self.items_)

    def __reversed__(self) -> Iterator:
        for x in self.generator:
            self.items_.append(x)
        return reversed(self.items_)

    def __iter__(self) -> Iterator:
        index = 0
        while True:
            try:
                yield self[index]
                index += 1
            except IndexError:
                break

    def __eq__(self, other):
        if isinstance(other, MutableSequence):
            return list(self) == other
        elif isinstance(other, LazyList):
            return list(self) == list(other)
        return False



def test_lazify_list():
    lst = [1, 2, 3, 4, 5]

    lazy_list = LazyList(lst)

    assert lst == lazy_list
    assert len(lst) == len(lazy_list)
    assert list(reversed(lst)) == list(reversed(lazy_list))
    assert 4 in lazy_list

    lst.append(100)
    lazy_list.append(100)
    assert lst == lazy_list

    lst.extend([1, 2, 3])
    lazy_list.extend([1, 2, 3])
    assert lst == lazy_list

    del lazy_list[1]
    assert lazy_list == [1, 3, 4, 5, 100, 1, 2, 3]
    assert lazy_list[:2] == [1, 3]
    print(lazy_list[6:])


def factorials():
    value = 1
    i = 1
    while True:
        yield value
        value *= i
        i += 1


def test_infinite_list():
    all_factorials = LazyList(factorials())
    print(all_factorials[4:7])
    assert all_factorials[4:7] == [24, 120, 720]
    assert all_factorials[:7] == [1, 1, 2, 6, 24, 120, 720]
    assert all_factorials[7] == 5040
    del all_factorials[6]
    assert all_factorials[6] == 5040
    all_factorials[:6] = [1]
    assert all_factorials[:2] == [1, 5040]
    del all_factorials[:2]
    assert all_factorials[:2] == [40320, 362880]
    all_factorials.append(100500)
    all_factorials.extend([1, 2, 3])
    assert any(factorial > 100000000 for factorial in all_factorials)
    assert not all(factorial < 500000 for factorial in all_factorials)
    assert 1307674368000 in all_factorials


def main():
    test_lazify_list()
    test_infinite_list()


if __name__ == '__main__':
    main()