/**
 * @file soccer2.cpp
 * @author n685
 * @brief
 * @date 2023-12-27
 *
 *
 */
#include "soccer.h"
#include <bits/stdc++.h>

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbgR(...) 4242
#define dbgP(...) 420
#define dbgRP(...) 420420
void nline() {}
#endif

template <class Node> struct ST {
  using T = typename Node::T;
  using RT = typename Node::RT;
  int sz, lg;
  std::vector<std::vector<Node>> st;
  int log(int num) { return 31 - __builtin_clz(num); }
  ST() {}
  ST(const std::vector<T> &arr) : sz((int)arr.size()), lg(log(sz)) {
    st.resize(lg + 1, std::vector<Node>(sz));
    for (int i = 0; i < sz; ++i) {
      st[0][i] = arr[i];
    }

    for (int i = 1; i <= lg; ++i) {
      for (int j = 0; j < sz; ++j) {
        if (j + (1 << i) - 1 >= sz) {
          break;
        }
        st[i][j].pull(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
      }
    }
  }
  RT query(int a, int b) {
    int l = log(b - a + 1);
    return Node::comb(st[l][a], st[l][b - (1 << l) + 1]);
  }
};

struct NodeMin {
  using T = std::pair<int, int>;
  using RT = T;
  static constexpr RT ID = std::pair{(int)1e9, (int)1e9};
  T val = ID;

  NodeMin() {}
  NodeMin(T v) : val(v) {}

  operator RT() { return val; }
  static RT comb(RT a, RT b) {
    if (b.first <= a.first) {
      return b;
    } else {
      return a;
    }
  }
  void set(T v) { val = v; }
  void pull(NodeMin &ll, NodeMin &rr) {
    if (rr.val.first <= ll.val.first) {
      val = rr.val;
    } else {
      val = ll.val;
    }
  }
};
struct NodeMin2 {
  using T = std::pair<int, int>;
  using RT = T;
  static constexpr RT ID = std::pair{(int)1e9, (int)1e9};
  T val = ID;

  NodeMin2() {}
  NodeMin2(T v) : val(v) {}

  operator RT() { return val; }
  static RT comb(RT a, RT b) {
    if (a.first <= b.first) {
      return a;
    } else {
      return b;
    }
  }
  void set(T v) { val = v; }
  void pull(NodeMin2 &ll, NodeMin2 &rr) {
    if (ll.val.first <= rr.val.first) {
      val = ll.val;
    } else {
      val = rr.val;
    }
  }
};
struct NodeMax {
  using T = std::pair<int, int>;
  using RT = T;
  static constexpr RT ID = std::pair{-(int)1e9, -(int)1e9};
  T val = ID;

  NodeMax() {}
  NodeMax(T v) : val(v) {}

  operator RT() { return val; }
  static RT comb(RT a, RT b) {
    if (a.first >= b.first) {
      return a;
    } else {
      return b;
    }
  }
  void set(T v) { val = v; }
  void pull(NodeMax &ll, NodeMax &rr) {
    if (ll.val.first >= rr.val.first) {
      val = ll.val;
    } else {
      val = rr.val;
    }
  }
};

struct Rect {
  int tr;
  int d;
  int l, r;
  int ii;
};

int biggest_stadium(int N, std::vector<std::vector<int>> F) {
  auto start = clock();
  auto n = N + 2;
  std::vector<std::pair<int, int>> tr;
  std::vector f(n, std::vector<int>(n, -1));
  auto insT = [&](int i, int j) {
    tr.emplace_back(i, j);
    f[i][j] = (int)tr.size() - 1;
  };
  for (int i = 0; i <= N + 1; ++i) {
    if (f[i][0] == -1) {
      insT(i, 0);
    }
    if (f[i][N + 1] == -1) {
      insT(i, N + 1);
    }
  }
  for (int j = 0; j <= N + 1; ++j) {
    if (f[0][j] == -1) {
      insT(0, j);
    }
    if (f[N + 1][j] == -1) {
      insT(N + 1, j);
    }
  }
  for (int i = 0; i < N; ++i) {
    for (int j = 0; j < N; ++j) {
      if (F[i][j]) {
        insT(i + 1, j + 1);
      }
    }
  }
  dbg(clock() - start);
  start = clock();

  int m = (int)tr.size();
  std::vector<ST<NodeMin>> mr(n);
  std::vector<ST<NodeMin2>> mr2(n), md(n);
  for (int i = n - 1; i >= 0; --i) {
    std::vector<std::pair<int, int>> ar, ar2, ad;
    if (i == n - 1) {
      // mr[i] = ST<NodeMin>(std::vector<NodeMin>(n));
      // mr2[i] = Seg<NodeMin2>(n);
      // md[i] = Seg<NodeMin>(n);
      ar.assign(n, NodeMin::ID);
      ar2.assign(n, NodeMin2::ID);
      ad.assign(n, NodeMin2::ID);
    } else {
      ar.resize(n);
      ar2.resize(n);
      ad.resize(n);
      for (int j = 0; j < n; ++j) {
        ar[j] = mr[i + 1].st[0][j];
        ar2[j] = mr2[i + 1].st[0][j];
        ad[j] = md[i + 1].st[0][j];
      }
    }
    for (int j = 0; j < n; ++j) {
      if (f[j][i] >= 0) {
        ar[j] = std::pair{i, f[j][i]};
        ar2[j] = std::pair{i, f[j][i]};
      }
      if (f[i][j] >= 0) {
        ad[j] = std::pair{i, f[i][j]};
      }
    }
    mr[i] = ar;
    mr2[i] = ar2;
    md[i] = ad;
  }
  std::vector<ST<NodeMax>> mu(n);
  for (int i = 0; i < n; ++i) {
    std::vector<std::pair<int, int>> au;
    if (i == 0) {
      au.assign(n, NodeMax::ID);
    } else {
      au.resize(n);
      for (int j = 0; j < n; ++j) {
        au[j] = mu[i - 1].st[0][j];
      }
    }
    for (int j = 0; j < n; ++j) {
      if (f[i][j] >= 0) {
        // mu[i].set(j, std::pair{i, f[i][j]});
        au[j] = std::pair{i, f[i][j]};
      }
    }
    mu[i] = au;
  }
  dbg(clock() - start);
  start = clock();

  std::vector<Rect> rt;
  std::vector<std::vector<int>> id(m);
  for (int t = 0; t < m; ++t) {
    auto [a, b] = tr[t];
    if (a == n - 1) {
      continue;
    }
    int l = 0, r = n - 1;
    while (l <= r && l <= b && b <= r) {
      auto [$, ind] = md[a + 1].query(l, r);
      if (ind == (int)1e9) {
        break;
      }
      auto [i, j] = tr[ind];
      if (i > a + 1 &&
          (rt.empty() || rt.back().tr != t || rt.back().d != i - 1)) {
        rt.push_back(Rect{t, i - 1, l, r, -1});
      }
      if (j <= b) {
        l = j + 1;
      } else {
        r = j - 1;
      }
    }
  }
  dbg(clock() - start);
  start = clock();

  std::sort(rt.begin(), rt.end(), [&](const auto &a, const auto &b) {
    return a.r - a.l > b.r - b.l;
  });
  int k = (int)rt.size();
  for (int i = 0; i < k; ++i) {
    id[rt[i].tr].push_back(i);
    rt[i].ii = (int)id[rt[i].tr].size() - 1;
  }
  dbg(clock() - start);
  start = clock();

  auto added = [&](const Rect &orig, const Rect &nxt) {
    auto [i1, d1, l1, r1, ii1] = orig;
    auto [i2, d2, l2, r2, ii2] = nxt;
    int u1 = tr[i1].first + 1;
    int u2 = tr[i2].first + 1;
    return (r2 - l2 + 1) * ((d2 - u2) - (d1 - u1));
  };
  std::vector<int> dp(k);
  for (int i = 0; i < k; ++i) {
    auto [ind, d, l, r, ii] = rt[i];
    int u = tr[ind].first + 1;
    dp[i] = (d - u + 1) * (r - l + 1);
  }
  int ans = 0;
  for (int i = 0; i < k; ++i) {
    ans = std::max(ans, dp[i]);
    auto [ind, d, l1, r1, ii] = rt[i];
    int u = tr[ind].first + 1;

    if (ii < (int)id[ind].size() - 1) {
      // Rect &r2 = rt[id[ind][ii + 1]];
      // dp[id[ind][ii + 1]] =
      //     std::max(dp[id[ind][ii + 1]], dp[i] + added(rt[i], r2));
      int r2 = id[ind][ii + 1];
      dp[r2] = std::max(dp[r2], dp[i] + added(rt[i], rt[r2]));
    }
    int l = l1;
    int r = r1;
    while (l <= r) {
      auto [$, i3] = mu[u].query(l, r);
      if (i3 < 0 || tr[i3].first != u - 1) {
        break;
      }
      if (tr[i3].second - 1 >= l) {
        auto [$$, i2] = mu[u].query(l, tr[i3].second - 1);
        int r2 = *std::lower_bound(
            id[i2].begin(), id[i2].end(), l, [&](const auto &a, const auto &v) {
              return rt[a].l < l || rt[a].r > tr[i3].second - 1;
            });
        dp[r2] = std::max(dp[r2], dp[i] + added(rt[i], rt[r2]));
      }
      l = tr[i3].second + 1;
    }
    if (l <= r) {
      auto [$$, i3] = mu[u].query(l, r);
      int r2 = *std::lower_bound(id[i3].begin(), id[i3].end(), l,
                                 [&](const auto &a, const auto &v) {
                                   return rt[a].l < l || rt[a].r > r;
                                 });
      dp[r2] = std::max(dp[r2], dp[i] + added(rt[i], rt[r2]));
    }

    l = l1;
    r = r1;
    while (l <= r) {
      auto [$, i3] = md[d].query(l, r);
      if (i3 < 0 || tr[i3].first != d + 1) {
        break;
      }
      if (tr[i3].second - 1 >= l) {
        auto [$$, i2] = mu[u].query(l, tr[i3].second - 1);
        int r2 = *std::lower_bound(
            id[i2].begin(), id[i2].end(), l, [&](const auto &a, const auto &v) {
              return rt[a].l < l || rt[a].r > tr[i3].second - 1;
            });
        dp[r2] = std::max(dp[r2], dp[i] + added(rt[i], rt[r2]));
      }
      l = tr[i3].second + 1;
    }
    if (l <= r) {
      auto [$$, i3] = mu[u].query(l, r);
      int r2 = *std::lower_bound(id[i3].begin(), id[i3].end(), l,
                                 [&](const auto &a, const auto &v) {
                                   return rt[a].l < l || rt[a].r > r;
                                 });
      dp[r2] = std::max(dp[r2], dp[i] + added(rt[i], rt[r2]));
    }
  }
  dbg(clock() - start);
  start = clock();
  return ans;
}