#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <map>
#include <set>

using namespace std;

#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#define pb push_back
#define mp make_pair
#define sz(x) ((int)(x).size())

typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef pair<int, int> pii;

const int MAXN = 510;
int ecnt;

bool can[MAXN][MAXN];
int cans[MAXN][MAXN + 1];

int dyn[MAXN][MAXN][2];

int n;
inline int modna(int x) {
//  assert(0 <= x && x < 2 * n);
  return x >= n ? x - n : x;
}
inline int modnm(int x) {
//  assert(-n < x && x < n);
  return x < 0 ? x + n : x;
}
/*inline int modn(int x) {
  if (x < 0) x += n;
  if (x >= n) x -= n;
  assert(0 <= x && x < n);
  return x;
}*/

int dyn2[MAXN][MAXN][2];
int dyn3[2][MAXN][MAXN];

int main() {
  #ifdef DEBUG
  freopen("std.in", "r", stdin);
  freopen("std.out", "w", stdout);
  #endif

  int type;
  while (scanf("%d%d", &n, &type) >= 1) {
    memset(can, 0, sizeof can);
    for (int i = 0; i < n; i++) {
      for (int pos = 0;; pos++) {
        int x;
        scanf("%d", &x);
        cans[i][pos] = x - 1;
        if (!x) break;

        x--;
        can[i][x] = true;
      }
    }
    memset(dyn, 0, sizeof dyn);

    for (int len = 2; len <= n; len++)
      for (int st = 0; st < n; st++) {
        {// 0
          int en = modna(st + len - 1);
          for (int ne = modna(st + 1);; ne = modna(ne + 1)) {
            if (can[st][ne])
              dyn[en][st][0] = max(dyn[en][st][0], 1 + max(dyn[en][ne][0], dyn[modna(st + 1)][ne][1]));
            if (ne == en) break;
          }
        }
        {// 1
          int en = modnm(st - len + 1);
          for (int ne = modnm(st - 1);; ne = modnm(ne - 1)) {
            if (can[st][ne])
              dyn[en][st][1] = max(dyn[en][st][1], 1 + max(dyn[en][ne][1], dyn[modnm(st - 1)][ne][0]));
            if (ne == en) break;
          }
        }
      }
    pii ans(-1, -1);
    for (int st = 0; st < n; st++) {
      int en = modnm(st - 1);
      ans = max(ans, mp(dyn[en][st][0], st));
    }

    if (type) {
//      eprintf("%d\n", clock());
      memset(dyn3, 0x80, sizeof dyn3);
      for (int i = 0; i < n; i++) dyn3[0][i][i] = dyn3[1][i][i] = 0;
      for (int len = 2; len <= n; len++)
        for (int st = 0; st < n; st++) { // 0
          int en = modna(st + len - 1);
          for (int ne = modna(st + 1);; ne = modna(ne + 1)) {
            if (can[st][ne])
              dyn3[0][st][en] = max(dyn3[0][st][en], 1 + dyn3[0][ne][en]);
            if (ne == en) break;
          }
        }
      for (int len = 2; len <= n; len++)
        for (int st = 0; st < n; st++) { // 1
          int en = modnm(st - len + 1);
          for (int ne = modnm(st - 1);; ne = modnm(ne - 1)) {
            if (can[st][ne])
              dyn3[1][st][en] = max(dyn3[1][st][en], 1 + dyn3[1][ne][en]);
            if (ne == en) break;
          }
        }
//      eprintf("%d\n", clock());

      memset(dyn2, 0, sizeof dyn2);
      for (int c = 0; c < n; c++) {
        for (int i = 0; i < n; i++)
          dyn2[i][i][0] = dyn2[i][i][1] = !!can[c][i];

        for (int en = 0; en < n; en++) {
          // 0
          for (int st = modnm(en - 1); st != en; st = modnm(st - 1)) {
            int &val = dyn2[st][en][0] = dyn2[modna(st + 1)][en][0];
            if (can[c][st])
              val = max(val, 1 + dyn[en][st][0]);
          }
          // 1
          for (int st = modna(en + 1); st != en; st = modna(st + 1)) {
            int &val = dyn2[st][en][1] = dyn2[modnm(st - 1)][en][1];
            if (can[c][st])
              val = max(val, 1 + dyn[en][st][1]);
          }
        }

        for (int a = 0; a < n; a++) if (a != c)
        for (int i = 0; cans[a][i] >= 0; i++) {
          int b = cans[a][i];
          if (b == c) continue;
          int dir = ((a > b) + (a > c) + (b > c)) & 1;

          int cans = 1;
          cans += dyn3[dir][b][c];

          if (dir == 0) {
            int st = modna(a + 1);
            if (st != b) {
              int en = modnm(b - 1);
              cans += max(dyn2[st][en][0], dyn2[en][st][1]);
            }
          } else {
            int st = modnm(a - 1);
            if (st != b) {
              int en = modna(b + 1);
              cans += max(dyn2[st][en][1], dyn2[en][st][0]);
            }
          }
          if (cans > ans.first) {
            ans.first = cans;
            ans.second = a;
          }
        }
      }
//      eprintf("%d\n", clock());
    }
    #ifdef DEBUG
    printf("%d\n", ans.first);
    #else
    printf("%d\n%d\n", ans.first, ans.second + 1);
    #endif
  }
  #ifdef DEBUG
  eprintf("time=%d\n", clock());
  #endif
  return 0;
}