params = (*params[:-1], *params[-1].__args__)
        return super().copy_with(params)
@_SpecialForm
def Unpack(self, parameters):
    """Type unpack operator.
    The type unpack operator takes the child types from some container type,
    such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'.
    For example::
        # For some generic class `Foo`:
        Foo[Unpack[tuple[int, str]]]  # Equivalent to Foo[int, str]
        Ts = TypeVarTuple('Ts')
        # Specifies that `Bar` is generic in an arbitrary number of types.
        # (Think of `Ts` as a tuple of an arbitrary number of individual
        #  `TypeVar`s, which the `Unpack` is 'pulling out' directly into the
        #  `Generic[]`.)
        class Bar(Generic[Unpack[Ts]]): ...
        Bar[int]  # Valid
        Bar[int, str]  # Also valid
    From Python 3.11, this can also be done using the `*` operator::
        Foo[*tuple[int, str]]
        class Bar(Generic[*Ts]): ...
    Note that there is only some runtime checking of this operator. Not
    everything the runtime allows may be accepted by static type checkers.
    For more information, see PEP 646.
    """
    item = _type_check(parameters, f'{self} accepts only single type.')
    return _UnpackGenericAlias(origin=self, args=(item,))
class _UnpackGenericAlias(_GenericAlias, _root=True):
    def __repr__(self):
        # `Unpack` only takes one argument, so __args__ should contain only