#ifdef _DEBUG
#define _GLIBCXX_DEBUG
#endif
#define _CRT_SECURE_NO_WARNINGS
#include <ext/pb_ds/assoc_container.hpp>
#include <bits/stdc++.h>

using namespace __gnu_pbds;
using namespace std;

typedef long long ll;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long double ld;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

#define mk make_pair
#define inb push_back
#define enb emplace_back
#define X first
#define Y second
#define all(v) v.begin(), v.end()
#define sqr(x) (x) * (x)
#define TIME 1.0 * clock() / CLOCKS_PER_SEC
#define y1 AYDARBOG
//continue break pop_back return

int solve();

int main()
{
    //ios_base::sync_with_stdio(0);
    //cin.tie(0);
#define TASK "intercity"
#ifndef _DEBUG
    //freopen(TASK".in", "r", stdin), freopen(TASK".out", "w", stdout);
#endif
    solve();
#ifdef _DEBUG
    fprintf(stderr, "\nTIME: %.3f\n", TIME);
#endif
}

const int INF = 2e9 + 7;
const ll LINF = 1e18;

const int BUFSZ = (int)1e6 + 7;
char buf[BUFSZ];
string get_str()
{
    scanf(" %s", buf);
    return string(buf);
}

int solve()
{
    int n;
    int root;
    scanf("%d %d", &n, &root);
    --root;
    vector<vi> g(n);
    vector<vi> ans(n);
    for (int i = 0; i < n; ++i)
    {
        int sz;
        scanf("%d", &sz);
        g[i].resize(sz);
        ans[i].resize(sz);
        for (int j = 0; j < sz; ++j)
        {
            scanf("%d", &g[i][j]);
            --g[i][j];
        }
    }
    vector<ll> cnt(n);
    auto cntinv = [&](ordered_set &tx, ordered_set &ty)
    {
        ll ans = 0;
        if (tx.size() < ty.size())
        {
            for (int xx : tx)
            {
                ans += ty.order_of_key(xx);
            }
        }
        else
        {
            for (int yy : ty)
            {
                ans += tx.size() - tx.order_of_key(yy);
            }
        }
        return ans;
    };
    vector<ll> dp;
    vi p;
    function<void(int, ordered_set&)> dfs = [&](int u, ordered_set& cur)
    {
        int sz = g[u].size();
        if (!sz)
        {
            cur.insert(u);
            return;
        }
        vector<ordered_set> t(sz);
        int it = 0;
        for (int to : g[u])
        {
            dfs(to, t[it]);
            ++it;
            cnt[u] += cnt[to];
        }
        puts("IN");
        vector<vector<ll>> lcnt(sz, vector<ll>(sz));
        p.assign(1 << sz, -1);
        dp.assign(1 << sz, LINF);
        dp[0] = 0;
        for (int i = 0; i < sz; ++i)
        {
            for (int j = i + 1; j < sz; ++j)
            {
                lcnt[i][j] = cntinv(t[i], t[j]);
                lcnt[j][i] = (ll)t[i].size() * (ll)t[j].size() - lcnt[i][j];
            }
        }
        puts("POSCHITALI INVERSII PAR");
        for (int i = 0; i < sz; ++i)
        {
            if (cur.size() < t[i].size())
                cur.swap(t[i]);
            for (auto &x : t[i])
                cur.insert(x);
        }
        puts("SLILI PARASHU");
        for (int msk = 0; msk < (1 << sz); ++msk)
        {
            vi cur;
            for (int i = 0; i < sz; ++i)
            {
                if ((msk >> i) & 1)
                    cur.inb(i);
            }
            for (int i = 0; i < sz; ++i)
            {
                if ((msk >> i) & 1)
                    continue;
                ll w = 0;
                for (int x : cur)
                {
                    w += lcnt[x][i];
                }
                if (dp[msk | (1 << i)] > dp[msk] + w)
                {
                    dp[msk | (1 << i)] = dp[msk] + w;
                    p[msk | (1 << i)] = i;
                }
            }
        }
        puts("POSCHITALI DP");
        vi res;
        int cmsk = (1 << sz) - 1;
        while (cmsk)
        {
            res.inb(p[cmsk]);
            cmsk ^= (1 << p[cmsk]);
        }
        reverse(all(res));
        for (int i = 0; i < sz; ++i)
        {
            ans[u][i] = g[u][res[i]] + 1;
        }
        cnt[u] += dp[(1 << sz) - 1] + (cur.size() - cur.order_of_key(u));
        cur.insert(u);
    };
    ordered_set tupaset;
    dfs(root, tupaset);
    printf("%lld\n", cnt[root]);
    for (int i = 0; i < n; ++i)
    {
        printf("%d ", (int)ans[i].size());
        for (int x : ans[i])
            printf("%d ", x);
        puts("");
    }
    return 0;
}