#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 {
using u64 = uint64_t;
static constexpr unsigned int lgW = 6;
static constexpr unsigned int W = 1u << lgW;
static constexpr int inf = 1 << 30;
inline int ctz(u64 n) { return n ? __builtin_ctzll(n) : -1; }
inline int clz(u64 n) { return n ? 63 - __builtin_clzll(n) : -1; }

template <int LOG, class D = void>
struct vEB_tree_node {
  using Chd = vEB_tree_node<(LOG >> 1)>;

  Chd map;
  int mn, mx;
  static constexpr int shift = (LOG >> 1) * lgW;
  array<Chd, 1 << shift> chd;

  inline int mask(u64 key) const { return key & ((1 << shift) - 1); }

  constexpr vEB_tree_node() : mn(inf), mx(-1) {}

  void insert(int key) {
    mn = std::min(mn, key), mx = std::max(mx, key);
    int pos = key >> shift;
    if (chd[pos].empty()) map.insert(pos);
    chd[pos].insert(mask(key));
  }

  void erase(int key) {
    int pos = key >> shift;
    if (chd[pos].empty()) return;
    chd[pos].erase(mask(key));
    if (chd[pos].empty()) map.erase(pos);
    if (mn == key) {
      if (mx == key) {
        mn = inf, mx = -1;
      } else {
        int p = map.min();
        mn = (p << shift) + chd[p].min();
      }
    } else if (mx == key) {
      int p = map.max();
      mx = (p << shift) + chd[p].max();
    }
  }

  bool contain(int key) const {
    int pos = key >> shift;
    return chd[pos].contain(mask(key));
  }

  inline bool empty() const { return mx == -1; }
  inline int min() const { return mn == inf ? -1 : mn; }
  inline int max() const { return mx; }

  // 以上(存在しない時は-1)
  int find_next(int key) const {
    if (key <= min()) return min();
    if (max() < key) return -1;
    int pos = key >> shift;
    if (map.contain(pos) && mask(key) <= chd[pos].max()) {
      return (pos << shift) + chd[pos].find_next(mask(key));
    }
    int nxt = map.find_next(pos + 1);
    if (nxt == -1) return -1;
    return (nxt << shift) + chd[nxt].min();
  }

  // 未満(存在しない時は-1)
  int find_prev(int key) const {
    if (max() < key) return max();
    if (key <= min()) return -1;
    int pos = key >> shift;
    if (map.contain(pos) && chd[pos].min() < mask(key)) {
      return (pos << shift) + chd[pos].find_prev(mask(key));
    }
    int nxt = map.find_prev(pos);
    if (nxt == -1) return -1;
    return (nxt << shift) + chd[nxt].max();
  }
};

template <int LOG>
struct vEB_tree_node<LOG, typename std::enable_if<LOG == 1>::type> {
  u64 map;
  vEB_tree_node() : map(0) {}
  inline void insert(int key) { map |= 1ULL << key; }
  inline void erase(int key) { map &= ~(1ULL << key); }
  inline bool contain(int key) const { return (map >> key) & 1; }
  inline bool empty() const { return map == 0; }
  inline int min() const { return ctz(map); }
  inline int max() const { return clz(map); }
  int find_next(int key) const { return ctz(map & ~((1ULL << key) - 1)); }
  int find_prev(int key) const { return clz(map & ((1ULL << key) - 1)); }
};

}  // namespace vEB_tree_impl

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

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

vEB_tree_impl::vEB_tree_node<4> ds;

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];
    }
  }
  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!