#include <bits/stdc++.h>

using namespace std;

#define int long long
#define rep(i, s, e) for (int i = s; i <= e; ++i)
#define drep(i, s, e) for (int i = s; i >= e; --i)
#define file(a) freopen(#a".in", "r", stdin), freopen(#a".out", "w", stdout)
#define pv(a) cout << #a << " = " << a << endl
#define pa(a, l, r) cout << #a " : "; rep(_, l, r) cout << a[_] << ' '; cout << endl

const int N = 6e2 + 10;

int read() {
  int x = 0, f = 1; char c = getchar();
  for (; c < '0' || c > '9'; c = getchar()) if (c == '-') f = -1;
  for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
  return x * f;
}

int n, k;
vector <int> a[N];

int pre[N], tag[N], p[N], dfn[N], dn, ans, p0[N], ans0;
bool e[N][N], e0[N][N];
queue <int> q;

int fa[N];
int get(int u) { return u == fa[u] ? u : fa[u] = get(fa[u]); }

int LCA(int u, int v) {
  for (++ dn; ; u = pre[p[u]], swap(u, v)) {
    if (dfn[u = get(u)] == dn) return u;
    else if (u) dfn[u] = dn;
  }
}

void shrink(int u, int v, int w) {
  for (; get(u) != w; u = pre[v]) {
    pre[u] = v, v = p[u], fa[u] = fa[v] = w;
    if (tag[v] == 2) q.push(v), tag[v] = 1;
  }
}

void rev(int u) {
  if (p[pre[u]]) rev(p[pre[u]]);
  p[pre[u]] = u, p[u] = pre[u];
}

bool blossom(int s) {
  rep(i, 1, n + 1) pre[i] = tag[i] = 0, fa[i] = i;
  q = queue <int> (), tag[s] = 1, q.push(s);
  while (q.size()) {
    int u = q.front(); q.pop();
    rep(v, 1, n + 1) if (e[u][v]) {
      if (tag[v] == 1) {
        int w = LCA(u, v);
        shrink(u, v, w), shrink(v, u, w);
      }
      else if (!tag[v]) {
        pre[v] = u, tag[v] = 2;
        if (!p[v]) {
          rev(v), ++ ans;
          return true;
        }
        tag[p[v]] = 1, q.push(p[v]);
      }
    }
  }
  return false;
}

bool check(int d) {
  ans = dn = 0;
  rep(i, 1, n + 1) {
    p[i] = dfn[i] = 0;
    rep(j, 1, n + 1) e[i][j] = false;
  }
  auto adde = [&](int u, int v) {
    e[u][v] = e[v][u] = true;
  } ;
  rep(i, 1, n) rep(j, i + 1, n) {
    if (a[i][0] + d <= a[j].back()) adde(i, j);
    else if (a[j][0] + d <= a[i].back()) adde(i, j);
  }
  rep(i, 1, n) rep(j, 1, n) e0[i][j] = e[i][j];
  rep(i, 1, n) if (!p[i]) blossom(i);
  ans0 = ans;
  rep(i, 1, n) p0[i] = p[i];
  rep(i, 1, n) {
    int x = i, y = n + 1;
    for (auto v : a[i]) {
      int cx = 0, cy = 0, px = -1, py = -1;
      rep(j, 1, n) if (j != i) {
        e[j][x] = e[x][j] = a[j][0] + d <= v;
        if (e[j][x]) ++ cx, px = j;
        e[j][y] = e[y][j] = v + d <= a[j].back();
        if (e[j][y]) ++ cy, py = j;
      }
      if (!cx || !cy || (cx == 1 && cy == 1 && px == py)) continue;
      // ensuring the correctness of the adjustment method
      auto work = [&](int u) {
        if (!p[u]) blossom(u);
        else if (!e[u][p[u]]) {
          int z = p[u];
          p[u] = p[z] = 0, -- ans;
          blossom(u);
          if (!p[z]) blossom(z);
        }
      } ;
      work(x), work(y);
      if (ans > (n - k) / 2) return true;
    }
    ans = ans0, p[n + 1] = 0;
    rep(j, 1, n) {
      p[j] = p0[j];
      e[x][j] = e[j][x] = e0[x][j];
      e[y][j] = e[j][y] = false;
    }
  }
  return false;
}

signed main() {
  n = read(), k = read();
  if (n - k & 1) return printf("Impossible\n"), 0;
  for (int i = 1, t; i <= n; ++ i) {
    a[i].resize(t = read());
    rep(j, 0, t - 1) a[i][j] = read();
    sort(a[i].begin(), a[i].end());
  }
  int l = 0, r = 1e18;
  while (l < r) {
    int mid = (l + r) >> 1;
    if (check(mid + 1)) l = mid + 1;
    else r = mid;
  }
  printf("%lld\n", l);
  return 0;
}