#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(g))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

namespace vEB_tree_impl {

#ifdef _WIN32
using uint = unsigned;
#endif
using ull = unsigned long long;

template<int LG, class T = void>
struct vEB_tree_t {
  static constexpr uint shf = LG * 3;
  static constexpr uint bas = (1U << shf) - 1;

  using _vEB_tree_t = vEB_tree_t<LG / 2>;

  _vEB_tree_t msk;
  std::array<_vEB_tree_t, 1 << shf> ch;

  int mn, mx;

  vEB_tree_t () : mn(1 << 30), mx(-1) {}

  bool empty () const {
    return mx == -1;
  }

  int min () const {
    return mn;
  }
  int max () const {
    return mx;
  }

  void insert (int x) {
    if (mx == -1) {
      mn = mx = x;
      return;
    }
    if (x == mn) {
      return;
    }
    if (x < mn) {
      std::swap(x, mn);
    }
    mx = std::max(mx, x);
    int p = x >> shf;
    if (ch[p].empty()) {
      msk.insert(p);
    }
    ch[p].insert(x & bas);
  }

  void erase (int x) {
    if (x == min()) {
      if (x == max()) {
        mn = 1U << 30, mx = -1;
      } else {
        int p = msk.min();
        mn = (p << shf) | ch[p].min();
        ch[p].erase(ch[p].min());
        if (ch[p].empty()) {
          msk.erase(p);
        }
      }
    } else {
      int p = x >> shf;
      if (ch[p].empty()) {
        return;
      }
      ch[p].erase(x & bas);
      if (ch[p].empty()) {
        msk.erase(p);
      }
      if (x == max()) {
        p = msk.max();
        mx = ~p ? (p << shf) | ch[p].max() : min();
      }
    }
  }
  
  bool contain (int x) {
    if (x == min()) {
      return true;
    }
    int p = x >> shf;
    return !ch[p].empty() && ch[p].contain(x & bas);
  }

  int find_next (int x) {
    if (x > max()) {
      return -1;
    }
    if (x <= min()) {
      return min();
    }
    int p = x >> shf;
    x &= bas;
    if (x <= ch[p].max()) {
      return (p << shf) | ch[p].find_next(x);
    }
    int y = msk.find_next(p + 1);
    return ~y ? (y << shf) | ch[y].find_next(x) : -1;
  }

  int find_prev (int x) {
    if (x <= min()) {
      return -1;
    }
    if (x > max()) {
      return max();
    }
    int p = x >> shf;
    x &= bas;
    if (x > ch[p].min()) {
      return (p << shf) | ch[p].find_prev(x);
    }
    int y = msk.find_prev(p);
    return ~y ? (y << shf) | ch[y].find_prev(x) : min();
  }
};

inline constexpr uint lb (ull x) {
  return x ? __builtin_ctzll(x) : -1;
}
inline constexpr uint hb (ull x) {
  return x ? 63 - __builtin_clzll(x) : -1;
}

template<int LG>
struct vEB_tree_t<LG, typename std::enable_if<LG == 1>::type> {
  ull msk;

  vEB_tree_t () : msk(0) {}

  bool empty () {
    return msk == 0;
  }
  int min () const {
    return lb(msk);
  }
  int max () const {
    return hb(msk);
  }
  bool contain (int x) {
    return msk >> x & 1;
  }
  void insert (int x) {
    msk |= 1ULL << x;
  }
  void erase (int x) {
    msk &= ~(1ULL << x);
  }
  int find_next (int x) {
    return lb(msk & ~((1ULL << x) - 1));
  }
  int find_prev (int x) {
    return hb(msk & ((1ULL << x) - 1));
  }
};

} 

using vEB_tree = vEB_tree_impl::vEB_tree_t<4>;

vEB_tree ds;

constexpr int N = 2e5 + 9;
constexpr int inf = 2e6;
int n, M, val[N * 3], tot;
vi a[N];

IL constexpr LL sq (int x) {
  return (LL)x * x;
}

struct calculator {
  int l, r;
  LL s;

  vi A, B;

  void init (int p) {
    int q = p ? p - 1 : n - 1;
    l = sz(a[q]);
    r = -1;
    vector<pair<int, int>> C;
    L (i, 0, sz(a[p]) - 1) {
      C.eb(a[p][i], i + 1);
    }
    L (i, 0, sz(a[q]) - 1) {
      C.eb(a[q][i], -i - 1);
    }
    sort(C.begin(), C.end());
    A.resize(sz(a[p]));
    B.resize(sz(a[q]));
    val[tot] = 0;
    ds.insert(tot++);
    L (i, 0, sz(C) - 1) {
      val[tot] = C[i].first;
      if (C[i].second > 0) {
        A[C[i].second - 1] = tot++;
      } else {
        B[-C[i].second - 1] = tot++;
      }
    }
    val[tot] = inf;
    ds.insert(tot++);
    s = (LL)inf * inf;
  }

  void ins (int x) {
    int a = ds.find_prev(x), b = ds.find_next(x);
    s += sq(val[x] - val[a]) + sq(val[x] - val[b]) - sq(val[a] - val[b]);
    ds.insert(x);
  }

  void era (int x) {
    ds.erase(x);
    int a = ds.find_prev(x), b = ds.find_next(x);
    s += sq(val[a] - val[b]) - sq(val[x] - val[a]) - sq(val[x] - val[b]);
  }

  LL gt (int ql, int qr) {
    while (l > ql) {
      ins(B[--l]);
    }
    while (r < qr) {
      ins(A[++r]);
    }
    while (l < ql) {
      era(B[l++]);
    }
    while (r > qr) {
      era(A[r--]);
    }
    return s;
  }
} c[N];

vector<LL> f[N];
vi g[N];

void DP (int k, int l, int r, int L, int R) {
  if (l > r || L > R) {
    return;
  }
  int m = (l + r) / 2;
  LL mn = 0;
  int p = -1;
  L (i, L, R) {
    LL w = f[k ? k - 1 : n - 1][i] + c[k].gt(i, m - 1);
    if (p == -1 || w < mn) {
      mn = w;
      p = i;
    }
  }
  f[k][m] = mn;
  g[k][m] = p;
  DP(k, l, m - 1, L, p);
  DP(k, m + 1, r, p, R);
}

struct inter {
  int L, R;
  inter (int a = 0, int b = 0) {
    L = a, R = b;
  }
};

LL ans;

void conq (vector<inter> q) {
  if (q[0].L > q[0].R) {
    return;
  }
  int m = (q[0].L + q[0].R) / 2;
  L (i, q[1].L, q[1].R) {
    f[1][i] = c[1].gt(m, i - 1);
  }
  L (i, 2, n - 1) {
    DP(i, q[i].L, q[i].R, q[i - 1].L, q[i - 1].R);
  }
  LL mn = 0;
  int p = -1;
  L (i, q[n - 1].L, q[n - 1].R) {
    LL w = f[n - 1][i] + c[0].gt(i, m - 1);
    if (p == -1 || w < mn) {
      mn = w;
      p = i;
    }
  }
  ans = min(ans, mn);
  auto ql = q, qr = q;
  R (i, n - 1, 1) {
    ql[i].R = qr[i].L = p;
    p = g[i][p];
  }
  ql[0].R = m - 1;
  qr[0].L = m + 1;
  conq(ql);
  conq(qr);
}

int main () {
  cin >> n;
  L (i, 0, n - 1) {
    int m;
    cin >> m;
    a[i].resize(m);
    L (j, 0, m - 1) {
      cin >> a[i][j];
    }
  }
  int idx = 0;
  L (i, 1, n - 1) {
    if (sz(a[i]) < sz(a[idx])) {
      idx = i;
    }
  }
  rotate(a, a + idx, a + n);
  vector<inter> init;
  L (i, 0, n - 1) {
    c[i].init(i);
    f[i].resize(sz(a[i]));
    g[i].resize(sz(a[i]));
    init.eb(0, sz(a[i]) - 1);
  }
  ans = LONG_LONG_MAX;
  conq(init);
  cout << ans << '\n';
}
// I love WHQ!