#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <queue>

using namespace std;

#define SZ(v) ((int)(v).size())
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repf(i, a, b) for (int i = (a); i <= (b); ++i)
const int maxint = -1u>>1;

#define sqr(x) ((x) * (x))

const double inf = 1e20;
    
int n, m;
double g[111][111];
int pre[111], id[111], mark[111], st[111], top, lft;
double cost[111];
bool v[111];

bool find_circle() {
    fill (v, v + n, false);
    for (int i = 1; i < n; ++i) {
        if (id[i] != i || v[i]) {
            continue;
        }
        fill (mark, mark + n, -1);
        top = 0;
        int temp = i;
        while (temp != 0 && mark[temp] == -1 && !v[temp]) {
            v[temp] = true;
            mark[temp] = top;
            st[top++] = temp;
            temp = pre[temp];
            //printf ("temp here %d\n", temp);
        }
        //printf ("temp %d mark %d\n", temp, mark[temp]);
        if (mark[temp] != -1) {
            lft = mark[temp];
            return true;
        }
    }
    return false;
}

double combine() {
    double res = 0.0;
    int now = st[lft];
    for (int i = lft; i < top; ++i) {
        int temp = st[i];
        res += cost[temp];
        id[temp] = now;
        for (int j = 0; j < n; ++j) {
            if (g[j][temp] != -1) {
                double tcost = g[j][temp] - cost[temp];
                if (g[j][now] == -1 || tcost < g[j][now])
                    g[j][now] = tcost;
            }
            if ((g[temp][j] != -1 && g[temp][j] < g[now][j]) || g[now][j] == -1) {
                g[now][j] = g[temp][j];
            }
        }
    }
    cost[now] = inf;
    for (int i = 1; i < n; ++i) {
        if (id[i] == i) {
            pre[i] = id[pre[i]];
        }
    }
    for (int i = 0; i < n; ++i) {
        if (i != now && id[i] == i && g[i][now] != -1 && g[i][now] < cost[now]) {
            pre[now] = i, cost[now] = g[i][now];
        }
    }
    return res;
}

double gao() {
    id[0] = 0;
    repf (i, 1, n - 1) {
        id[i] = i;
        cost[i] = inf;
        for (int j = 0; j < n; ++j) {
            if (i != j && g[j][i] != -1 && g[j][i] < cost[i]) {
                cost[i] = g[j][i];
                pre[i] = j;
            }
        }
    }
    double ans = 0;
    while (find_circle()) ans += combine();
    repf (i, 1, n - 1) {
        if (id[i] == i) {
            ans += cost[i];
        }
    }
    return ans;
}

double a[111][111], len[111];

int main() {
    while (scanf ("%d%d", &n, &m) != EOF) {
        rep (i, m) {
            len[i] = 0;
            rep (j, n) {
                scanf ("%lf", &a[i][j]);
                len[i] += a[i][j] * a[i][j];
            }
            len[i] = sqrt(len[i]);
        }
        rep (i, m) {
            rep (j, m) {
                if (i == j) continue;
                double now = 0.0;
                rep (k, n) {
                    now += a[i][k] * a[j][k];
                }
                now /= len[i] * len[j];
                now = sqrt (1.0 - now * now);
                g[j + 1][i + 1] = sqr(len[i] * now);
            }
            g[0][i + 1] = sqr(len[i]);
            g[i + 1][0] = -1;
            g[i + 1][i + 1] = -1;
        }
        g[0][0] = -1;
        n = m + 1;
        printf ("%.8lf\n", gao());
    }
    return 0;
}

Measured memory_bytes: 1436