This is the easy version of the problem. The difference between the versions is in the constraints on the array elements. You can make hacks only if all versions of the problem are solved.

You are given an array [a_1, a_2, ..., a_n]. 

Your goal is to find the length of the longest subarray of this array such that the most frequent value in it is not unique. In other words, you are looking for a subarray such that if the most frequent value occurs f times in this subarray, then at least 2 different values should occur exactly f times.

An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.

Input

The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ min(n, 100)) — elements of the array.

Output

You should output exactly one integer — the length of the longest subarray of the array whose most frequent value is not unique. If there is no such subarray, output 0.

Examples

Input


7
1 1 2 2 3 3 3


Output


6

Input


10
1 1 1 5 4 1 3 1 2 2


Output


7

Input


1
1


Output


0

Note

In the first sample, the subarray [1, 1, 2, 2, 3, 3] is good, but [1, 1, 2, 2, 3, 3, 3] isn't: in the latter there are 3 occurrences of number 3, and no other element appears 3 times.
#include <bits/stdc++.h>
#pragma GCC target("avx2,avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
istream& operator>>(istream& is, __int128_t& x) {
  x = 0;
  string s;
  is >> s;
  int n = int(s.size()), it = 0;
  if (s[0] == '-') it++;
  for (; it < n; it++) x = (x * 10 + s[it] - '0');
  if (s[0] == '-') x = -x;
  return is;
}
ostream& operator<<(ostream& os, __int128_t x) {
  if (x == 0) return os << 0;
  if (x < 0) os << '-', x = -x;
  deque<int> deq;
  while (x) deq.emplace_front(x % 10), x /= 10;
  for (int e : deq) os << e;
  return os;
}
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
  return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  os << "{";
  for (int i = 0; i < int(v.size()); i++) {
    if (i) os << ", ";
    os << v[i];
  }
  return os << "}";
}
template <class Container>
inline int SZ(Container& v) {
  return int(v.size());
}
template <class T>
inline void UNIQUE(vector<T>& v) {
  v.erase(unique(v.begin(), v.end()), v.end());
}
template <class T1, class T2>
inline bool chmax(T1& a, T2 b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T1, class T2>
inline bool chmin(T1& a, T2 b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
inline int topbit(ull x) { return x == 0 ? -1 : 63 - __builtin_clzll(x); }
inline int botbit(ull x) { return x == 0 ? 64 : __builtin_ctzll(x); }
inline int popcount(ull x) { return __builtin_popcountll(x); }
inline int kthbit(ull x, int k) { return (x >> k) & 1; }
inline constexpr long long TEN(int x) { return x == 0 ? 1 : TEN(x - 1) * 10; }
inline void print() { cout << "\n"; }
template <class T>
inline void print(const vector<T>& v) {
  for (int i = 0; i < int(v.size()); i++) {
    if (i) cout << " ";
    cout << v[i];
  }
  print();
}
template <class T, class... Args>
inline void print(const T& x, const Args&... args) {
  cout << x << " ";
  print(args...);
}
struct fast_ios {
  fast_ios() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
  };
} fast_ios_;
constexpr int B = 450;
int main() {
  int N;
  cin >> N;
  vector<int> A(N);
  for (int i = 0; i < (N); i++) cin >> A[i], A[i]--;
  vector<int> cnt(N);
  for (int i = 0; i < (N); i++) cnt[A[i]]++;
  int F = *max_element((cnt).begin(), (cnt).end());
  int D = -1;
  for (int i = 0; i < (N); i++) {
    if (F == cnt[i]) {
      if (~D) {
        cout << N << ln;
        return 0;
      } else {
        D = i;
      }
    }
  }
  int ans = 0;
  vector<int> idx = {-1};
  for (int i = 0; i < (N); i++)
    if (A[i] == D) idx.emplace_back(i);
  idx.emplace_back(N);
  auto calc = [&](int len) {
    if (len > F) return;
    int posl = 0;
    int posr = 0;
    int good = 0;
    vector<int> freq(N);
    for (int l = 0; l + len + 1 < SZ(idx); l++) {
      while (posl <= idx[l]) {
        freq[A[posl]]--;
        if (A[posl] != D) {
          if (freq[A[posl]] == len) good++;
          if (freq[A[posl]] == len - 1) good--;
        }
        posl++;
      }
      int r = l + len + 1;
      while (posr < idx[r]) {
        freq[A[posr]]++;
        if (A[posr] != D) {
          if (freq[A[posr]] == len) good++;
          if (freq[A[posr]] == len + 1) good--;
        }
        posr++;
      }
      if (good) chmax(ans, posr - posl);
    }
  };
  for (int i = 1; i < B; i++) calc(i);
  vector<int> seen(2 * N + 1);
  for (int i = 0; i < (N); i++) {
    if (i == D) continue;
    if (cnt[i] >= B) {
      fill((seen).begin(), (seen).end(), -1);
      int d = N;
      seen[d] = 0;
      for (int j = 0; j < (N); j++) {
        if (A[j] == D) d++;
        if (A[j] == i) d--;
        if (~seen[d]) {
          chmax(ans, j + 1 - seen[d]);
        } else {
          seen[d] = j + 1;
        }
      }
    }
  }
  cout << ans << ln;
}
