In order to fly to the Moon Mister B just needs to solve the following problem.

There is a complete indirected graph with n vertices. You need to cover it with several simple cycles of length 3 and 4 so that each edge is in exactly 2 cycles.

We are sure that Mister B will solve the problem soon and will fly to the Moon. Will you?


-----Input-----

The only line contains single integer n (3 ≤ n ≤ 300).


-----Output-----

If there is no answer, print -1.

Otherwise, in the first line print k (1 ≤ k ≤ n^2) — the number of cycles in your solution.

In each of the next k lines print description of one cycle in the following format: first print integer m (3 ≤ m ≤ 4) — the length of the cycle, then print m integers v_1, v_2, ..., v_{m} (1 ≤ v_{i} ≤ n) — the vertices in the cycle in the traverse order. Each edge should be in exactly two cycles.


-----Examples-----
Input
3

Output
2
3 1 2 3
3 1 2 3

Input
5

Output
6
3 5 4 2
3 3 1 5
4 4 5 2 3
4 4 3 2 1
3 4 2 1
3 3 1 5

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = '#!/usr/bin/env python3\n\nfrom collections import defaultdict\n\nDEBUG = False\n\n\ndef main():\n    if DEBUG:\n        test()\n\n    n = int(input())\n\n    paths = cycles(n)\n\n    print(len(paths))\n    for p in paths:\n        print(\'%d %s\' % (len(p), \' \'.join([str(v) for v in p])))\n\n\ndef cycles(n):\n    """Builds a set of cycles for a fully connected graph with n vertices."""\n    if n % 2 == 0:\n        return even(n)\n    else:\n        return odd(n)\n\n\ndef even(n):\n    """Builds a set of cycles that a graph with even vertices."""\n    assert n % 2 == 0\n\n    # Base case for complete graph such that V = {1, 2, 3, 4}.\n    cycles = [[1, 2, 3], [2, 3, 4], [3, 4, 1], [4, 1, 2]]\n\n    for i in range(6, n + 1, 2):\n        a, b = i, i - 1\n\n        # Use edges (a, 1), (a, 0), (b, 1), (b, 0), (a, b) exactly twice each.\n        cycles += [[a, 1, b], [a, 2, b], [a, 1, b, 2]]\n\n        # Similar to odd(...) as we are left with 2n - 2 edges to use\n        # connected to i - 4 of the vertices V\' = {3 ... i - 2}. Notice that\n        # |V\'| is even so we can apply the same strategy as in odd(...).\n        for k in range(3, i - 1, 2):\n            c, d = k, k + 1\n            cycles += [[a, c, b, d]] * 2\n\n    return cycles\n\n\ndef odd(n):\n    """Builds a set of cycles that a graph with odd vertices."""\n    assert n % 2 == 1\n\n    # Base case for complete graph such that V = {1, 2, 3}.\n    cycles = [[1, 2, 3]] * 2\n\n    for i in range(5, n + 1, 2):\n        a, b = i, i - 1\n        # Say the new vertices are {a, b}. Since the graph is fully connected\n        # adding these 2 vertices results in 2n + 1 more edges. We use a length\n        # 3 cycle a -> b -> 1 > a twice to use up 3 of these edges.\n        cycles += [[a, b, 1]] * 2\n\n        # At this point we are left with 2n + 1 - 3 = 2n - 2 edges to use\n        # connected to i - 3 of the vertices V\' = {2 ... i - 2}. Notice that\n        # |V\'| is even. To use these edges and cover vertices V\' we take pairs\n        # c, d in V\' and create two of each path a -> c -> b -> d -> a.\n        for k in range(2, i - 1, 2):\n            c, d = k, k + 1\n            cycles += [[a, c, b, d]] * 2\n\n    return cycles\n\n\ndef test():\n    """Checks the cycles(...) solver for a bunch of inputs."""\n    print(\'Testing...\')\n\n    for n in range(3, 300, 21):\n        check(n, cycles(n))\n\n    print(\'Tests pass!\')\n\n\ndef check(n, paths):\n    """Checks the solution for errors."""\n    # Check that all vertices are covered.\n    vertices = set(sum(paths, list()))\n    assert vertices == set(range(1, n + 1))\n\n    # Check that each edge is used exactly twice.\n    counts = defaultdict(int)\n\n    for p in paths:\n        assert len(p) == 3 or len(p) == 4\n        assert len(set(p)) == len(p)\n\n        for i in range(len(p)):\n            key = tuple(sorted([p[i - 1], p[i]]))\n            counts[key] += 1\n\n    for i in range(1, n + 1):\n        for j in range(i + 1, n + 1):\n            assert counts[(i, j)] == 2\n\ndef __starting_point():\n    main()\n\n__starting_point()'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 15107