#include <bits/stdc++.h>
using namespace std;
using namespace chrono;

using ll = long long;
using ull = unsigned long long;

string to_string(const string &s) {
  return '"' + s + '"';
}

string to_string(bool b) {
  return b ? "true" : "false";
}

template <typename A, typename B>
string to_string(const pair<A, B> &p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename T>
string to_string(const T &v) {
  string s = "{";
  bool first = true;
  for (const auto &it : v) {
    if (!first)
      s += ", ";
    else
      first = false;
    s += to_string(it);
  }
  return s += "}";
}

void debug_out() {
  cerr << endl;
}

template <typename T, typename... Args>
void debug_out(const T &first, const Args&... rest) {
  cerr << to_string(first) << " ";
  debug_out(rest...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

auto startTime = high_resolution_clock::now();
int get_time() {
  auto stopTime = chrono::high_resolution_clock::now();
  auto duration = duration_cast<milliseconds>(stopTime - startTime);
  return duration.count(); // in ms
}

using ld = long double;

int n;
int w[11][11];
vector<ld> steps;

ld eval(vector<ld> &p) {
  ld sum = 0;
  for (int i = 1; i <= n; ++i) {
    for (int j = i + 1; j <= n; ++j)
      sum += p[i] * p[j] * w[i][j];
  }

  return sum;
}

void norm(vector<ld> &p) {
  ld sum = 0;
  for (int i = 1; i <= n; ++i)
    sum += p[i];

  for (int i = 1; i <= n; ++i)
    p[i] /= sum;
}


ld run_regr(vector<ld> &p) {
  while (get_time() <= 950) {
    ld best = eval(p), df;
    int pos = -1;
    vector<ld> aux = p;
    for (int i = 1; i <= n; ++i) {
      for (auto eps : steps) {
        p[i] += eps;
        norm(p);
        ld res = eval(p);
        if (res > best) {
          best = res;
          df = eps;
          pos = i;
        }
        p = aux;

        p[i] -= eps;
        if (p[i] >= 0) {
          norm(p);
          ld res = eval(p);
          if (res > best) {
            best = res;
            df = -eps;
            pos = i;
          }
        }
        p = aux;
      }
    }

    if (pos == -1) {
      return best;
    }

    p[pos] += df;
    norm(p);
  }

  return eval(p);
}

void solve() {
  cin >> n;
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= n; ++j) {
      cin >> w[i][j];
    }
  }

  ld step = 0.1;
  for (int i = 1; i <= 80; ++i) {
    steps.push_back(step);
    step /= 2;
  }

  vector<ld> p(n + 1, 0);
  ld best = 0;
  while (get_time() <= 900) {
    auto dis = uniform_real_distribution<ld>(0, 1);
    for (int i = 1; i <= n; ++i)
      p[i] = dis(rng);

    norm(p);
    best = max(best, run_regr(p));
  }
  cout << fixed << setprecision(20) << best << "\n";
}

int main() {
  cin.tie(NULL);
  ios_base::sync_with_stdio(false);

  int t = 1;
//  cin >> t;
  while (t--)
    solve();

  return 0;
}