from io import StringIO

# Alternative reconstruction of the standard range class (fancy version,
# allowing backwards iteration and step sizes other than 1).

class Range:
    def __init__(self, first, end, step=1):
        assert step != 0
        self._first, self._end, self._step = first, end, step

    def __getitem__(self, k):
        if k < 0:  # Python allows negative indices
            p = self._end + k * self._step
        else:
            p = self._first + k * self._step
        if self._step >= 1 and p >= self._end:
            raise IndexError
        elif self._stepo < 0 and p <= self._end:
            raise IndexError
        return p

class Link:
    empty = ()

    def __init__(self, first, rest=empty):
        self._first = first
        self._rest = rest

    def __getitem__(self, i):
        if i == 0:
            return self._first
        else:
            return self._rest[i-1]

    def __len__(self):
        return 1 + len(self._rest)

    # If __iter__ is omitted, Python can still work with __getitem__.!
    def __iter__(self):
        return Link._iter(self)

    class _iter:
        def __init__(self, lst):
            self._p = lst

        def __next__(self):
            if self._p is Link.empty:
                raise StopIteration
            r = self._p._first
            self._p = self._p._rest
            return r

    def __str__(self):
        r = StringIO()
        print("(", file=r, end="")
        sep = ""
        for p in self:
            print(sep + repr(p), file=r, end="")
            sep = ", "
        print(")", file=r, end="")
        return r.getvalue()

    def __repr__(self):
        return "Link({}, {})".format(repr(self._first), repr(self._rest))