def common_substr_2(
        seq1,
        seq2,
        sorting=None):
    """
    Find the longest common consecutive subsequence(s).
    This version works for two iterables.

    This is known as the `longest common substring` problem, or LCS for short.

    Args:
        seq1 (iterable): The first input sequence.
            Must be of the same type as seq2.
        seq2 (iterable): The second input sequence.
            Must be of the same type as seq1.
        sorting (callable): Sorting function passed to 'sorted' via `key` arg.

    Returns:
        commons (list[iterable]): The longest common subsequence(s).

    Examples:
        >>> common_substr_2('academy', 'abracadabra')
        ['acad']
        >>> common_substr_2('los angeles', 'lossless')
        ['los', 'les']
        >>> common_substr_2('los angeles', 'lossless', lambda x: x)
        ['les', 'los']
        >>> common_substr_2((1, 2, 3, 4, 5), (0, 1, 2))
        [(1, 2)]
    """
    # note: [[0] * (len(seq2) + 1)] * (len(seq1) + 1) will not work!
    counter = [[0 for j in range(len(seq2) + 1)] for i in range(len(seq1) + 1)]
    longest = 0
    commons = []
    for i, item in enumerate(seq1):
        for j, jtem in enumerate(seq2):
            if item == jtem:
                tmp = counter[i][j] + 1
                counter[i + 1][j + 1] = tmp
                if tmp > longest:
                    commons = []
                    longest = tmp
                    commons.append(seq1[i - tmp + 1:i + 1])
                elif tmp == longest:
                    commons.append(seq1[i - tmp + 1:i + 1])
    if sorting is None:
        return commons
    else:
        return sorted(commons, key=sorting)