#include <bits/stdc++.h>

using namespace std;

#define all(x) (x).begin(), (x).end()
using ll = long long;

template<typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "[";
    for (int i = 0; i < (int) v.size(); i++) {
        os << v[i] << (i + 1 == (int) v.size() ? "" : ", ");
    }
    os << "]";
    return os;
}


//#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl;
#define debug(...);


struct Simplex {
    bool infinity,      // which the problem is unbounded or not
    infeasible;     // which the problem is infeasible or not
    int n,              // the number of variables
    m;              // the number of constraints
    vector<double> x;   // optimal solution
    double opt;         // optimal value
    vector<int> index;  // indices of non-basis (< n) and basis (otherwise)
    int r, s;           // pivot row / column
    vector<vector<double>> tableau;

    /**
     * @brief Construct a new Simplex object
     *
     * @param A Coefficients of constraints
     * @param b Bounds of constraints
     * @param c Coefficients of objective function
     * @param mode choose pivot by smallest subscript rule if mode = 0, largest coefficient rule otherwise
     * @details Maximize cx s.t. Ax <= b and x >= 0
     */
    Simplex(const vector<vector<double>> &A, const vector<double> &b, const vector<double> &c) {
        infinity = infeasible = false;
        init(A, b, c);
        solve();
    }

private:
    static constexpr double EPS = 1e-10;

    inline int sgn(const double &x) { return x < -EPS ? -1 : x > EPS ? 1 : 0; }

    inline int compare(const double &a, const double &b) { return sgn(a - b); }

    inline bool equals(const double &a, const double &b) { return compare(a, b) == 0; }

    void init(const vector<vector<double>> &A, const vector<double> &b, const vector<double> &c) {
        m = A.size(), n = c.size();

        index.resize(n + 1 + m);
        iota(index.begin(), index.end(), 0);
        tableau.assign(m + 2, vector<double>(n + 2, 0));

        r = m;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) tableau[i][j] = -A[i][j];
            tableau[i][n] = 1;
            tableau[i][n + 1] = b[i];
            if (tableau[i][n + 1] < tableau[r][n + 1]) r = i;
        }
        for (int j = 0; j < n; j++) tableau[m][j] = c[j];
        tableau[m + 1][n] = -1;
    }

    void smallest_subscript_rule() {
        r = s = -1;
        for (int j = 0; j < n + 1; j++) {
            if (s < 0 or index[j] < index[s]) {
                if (compare(tableau[m + 1][j], 0) > 0 or
                    (equals(tableau[m + 1][j], 0) and compare(tableau[m][j], 0) > 0)) {
                    s = j;
                }
            }
        }
        if (s < 0) return;
        r = -1;
        for (int i = 0; i < m; i++) {
            if (compare(tableau[i][s], 0) >= 0) continue;
            if (r < 0)
                r = i;
            else if (compare(tableau[i][n + 1] / (-tableau[i][s]), tableau[r][n + 1] / (-tableau[r][s])) < 0)
                r = i;
            else if (equals(tableau[i][n + 1] / (-tableau[i][s]), tableau[r][n + 1] / (-tableau[r][s])) and
                     index[n + 1 + i] < index[n + 1 + r]) {
                r = i;
            }
        }
    }

    void solve() {
        vector<int> nonzero;
        for (s = n;;) {
            if (r < m) {
                swap(index[s], index[n + 1 + r]);
                tableau[r][s] = double(1) / tableau[r][s];
                nonzero.clear();
                for (int j = 0; j < n + 2; j++) {
                    if (j == s) continue;
                    tableau[r][j] *= -tableau[r][s];
                    if (!equals(tableau[r][j], 0)) nonzero.emplace_back(j);
                }
                for (int i = 0; i < m + 2; i++) {
                    if (i == r or equals(tableau[i][s], 0)) continue;
                    for (const auto &j: nonzero) tableau[i][j] += tableau[i][s] * tableau[r][j];
                    tableau[i][s] *= tableau[r][s];
                }
            }

            smallest_subscript_rule();
            if (s < 0) break;
            if (r < 0) {
                infinity = true;
                return;
            }
        }

        if (compare(tableau[m + 1][n + 1], 0) < 0) {
            infeasible = true;
            return;
        }
        x.assign(n, 0);
        for (int i = 0; i < m; i++) {
            if (index[n + 1 + i] < n) {
                x[index[n + 1 + i]] = tableau[i][n + 1];
            }
        }
        opt = tableau[m][n + 1];
    }
};

template<class T>
pair<T, int> gaussian(vector<vector<T>> &a, int last = 0) {
    int h = a.size();
    int w = a[0].size();
    T d = 1;
    int r = 0;
    for (int j = 0; j < w - last; j++) {
        int id = -1;
        for (int i = r; i < h; i++) {
            if (a[i][j] != T(0)) {
                id = i;
                break;
            }
        }
        if (id == -1) {
            d = 0;
            continue;
        }
        if (r != id) {
            d *= -1;
            swap(a[r], a[id]);
        }
        d *= a[r][j];
        for (int k = w - 1; k >= j; k--) {
            a[r][k] /= a[r][j];
        }
        for (int i = 0; i < h; i++) {
            if (i == r) continue;
            for (int k = w - 1; k >= j; k--) {
                a[i][k] -= a[r][k] * a[i][j];
            }
        }
        r++;
    }
    return {d, r};
}

template<typename T>
vector<vector<T>> linear(vector<vector<T>> &a, const vector<T> &b) {
    int h = a.size();
    int w = a[0].size();
    for (int i = 0; i < h; i++) a[i].emplace_back(b[i]);
    auto [det, rank] = gaussian(a, 1);
    for (int i = rank; i < h; i++) {
        if (a[i][w] != T(0)) {
            return vector<vector<T>>();
        }
    }
    vector<vector<T>> res(1, vector<T>(w));
    vector<int> p(w, -1);
    for (int i = 0, j = 0; i < rank and j < w; i++) {
        while (a[i][j] == T(0)) {
            j++;
        }
        res[0][j] = a[i][w];
        p[j] = i;
    }
    for (int j = 0; j < w; j++) {
        if (p[j] != -1) continue;
        vector<T> c(w);
        c[j] = 1;
        for (int k = 0; k < j; k++) {
            if (p[k] != -1) {
                c[k] = -a[p[k]][j];
            }
        }
        res.emplace_back(c);
    }
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;
    vector W(n, vector<int>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> W[i][j];
        }
    }

    auto f = [&](const vector<int> &inv, const vector<double> &x) {
        double res = 0;
        for (int i = 0; i < n; i++) {
            if (inv[i] == -1) continue;
            for (int j = i + 1; j < n; j++) {
                if (inv[j] == -1) continue;
                res += x[inv[i]] * W[i][j] * x[inv[j]];
            }
        }
        return res;
    };
    double ans = 0;
    auto calc = [&](int mask) -> double {
        vector<vector<double>> C;
        vector<int> inv(n, -1);
        int t = 0;
        for (int i = 0; i < n; i++) {
            if ((mask >> i) & 1) {
                inv[i] = t++;
            }
        }
        debug(inv);
        debug(t);
        vector<vector<double>> A;
        {
            
            vector<double> b;
            for (int i = 0; i < n; i++) {
                if ((~mask >> i) & 1) continue;
                for (int j = 0; j < n; j++) {
                    if ((~mask >> j) & 1) continue;
                    if (W[i][j] == 0) continue;
                    vector<double> a(t);
                    a[inv[i]] = 1;
                    a[inv[j]] = 0;
                    for (int k = 0; k < n; k++) {
                        if (k == i or k == j) continue;
                        if ((~mask >> k) & 1) continue;
                        a[inv[k]] = 0.5 - (W[i][k] - W[j][k]) * 1.0 / (2 * W[i][j]);
                    }
                    A.emplace_back(a);
                    b.emplace_back(0.5);
                }
            }
            {
                vector<double> a(t, 1);
                A.emplace_back(a);
                b.emplace_back(1);
            }
            C = linear(A, b);
            debug(A);
            debug(b);
        }
        if (C.empty()){
          vector<double> fuck(t,0);
          for (int i=0;i<t;i++){
            fuck[i] = A[i].back();
            if (fuck[i] < 0) return 0;
          }
          return f(inv,fuck);
          
        };
        for (int i = 0; i < int(C.size()); i++) {
            debug(C[i]);
        }
        {
            double res = f(inv,C[0]);
            int len = C.size();
            if (len > 1) {
                vector<vector<double>> A;
                vector<double> b, c;
                for (int i = 0; i < t; i++) {
                    vector<double> a;
                    for (int j = 1; j < len; j++) a.emplace_back(-C[j][i]);
                    A.emplace_back(a);
                    b.emplace_back(C[0][i]);
                }
                for (int i = 1; i < len; i++) c.emplace_back(f(inv, C[i]));
                Simplex simplex(A, b, c);
                if (simplex.infeasible) return 0;
                vector<double> d = C[0];
                for (int i = 1; i < len; i++) {
                    for (int j = 0; j < t; j++) {
                        d[j] += simplex.x[i - 1] * C[i][j];
                    }
                }
                debug(d);
                res = f(inv, d);
            } else {
                for (int i = 0; i < t; i++) {
                    if (C[0][i] < 0) {
                        return 0;
                    }
                }
                res = f(inv, C[0]);
            }
            return res;
        }
    };
    for (int i = (1 << n) - 1; i > 0; i--) {
        debug(i);
        double res = calc(i);
        debug(res);
        ans = max(ans, res);
    }
    cout << fixed << setprecision(10);
    cout << ans << "\n";
    return 0;
}