#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

#pragma region template

#define pb push_back

#if __cplusplus < 201703L
template <class T> T gcd(T a, T b) { return abs(__gcd(a, b)); }
template <class T> T clamp(T n, T l, T r) { return n < l ? l : n > r ? r : n; }
#endif
template <class T> T lcm(T a, T b) { return abs(a / gcd(a, b) * b); }
template <class T> T sgn(T n) { return n == 0 ? 0 : n > 0 ? 1 : -1; }

#define eprintf(...) fprintf(stderr, __VA_ARGS__)

ll bm(ll b, ll p, ll m) {
  ll r = 1;
  for (; p; p >>= 1, b = b * b % m)
    if (p & 1)
      r = r * b % m;
  return r;
}

// Generic modular integer.
template <int MOD> struct GModint {
  ll val;

  GModint() : val(0) {}
  GModint(ll v) : val(((v % MOD) + MOD) % MOD) {}

  const GModint operator-() const { return GModint(-val); }
  const GModint operator+(const GModint &g) const { return GModint(val + g.val); }
  const GModint operator-(const GModint &g) const { return *this + (-g); }
  const GModint operator*(const GModint &g) const { return GModint(val * g.val); }
  const GModint operator/(const GModint &g) const { return *this * g.inv(); }
  template <class T> const GModint operator^(const T t) const { return GModint(bm(val, t, MOD)); }
  const GModint inv() const { return GModint(bm(val, MOD - 2, MOD)); }
};

using Modint = GModint<1000000007>;

template <int MOD> ostream &operator<<(ostream &out, const GModint<MOD> m) {
  out << m.val;
  return out;
}

template <class T> ostream &operator<<(ostream &out, const vector<T> v) {
  out << "[";
  for (typename vector<T>::iterator it = v.begin(); it != v.end(); it++) {
    out << *it;
    if (next(it) != v.end())
      out << ", ";
  }
  out << "]";
  return out;
}

template <class T, class U> ostream &operator<<(ostream &out, const map<T, U> m) {
  out << "{";
  for (typename map<T, U>::const_iterator it = m.begin(); it != m.end(); it++) {
    out << it->first << " -> " << it->second;
    if (next(it) != m.end())
      out << ", ";
  }
  out << "}";
}

template <class T> ostream &operator<<(ostream &out, const set<T> s) {
  out << "(";
  for (typename set<T>::iterator it = s.begin(); it != s.end(); it++) {
    out << *it;
    if (next(it) != s.end())
      out << ", ";
  }
  out << ")";
}

template <class T, class U> ostream &operator<<(ostream &out, const pair<T, U> p) {
  out << "(" << p.first << ", " << p.second << ")";
  return out;
}

namespace DS {

// Building a 0-based sparse table for associative operations.
// i.e. A op (B op C) = (A op B) op C
template <class T, class Combiner> struct SparseTable {
  int n, nlog;
  T **st;
  Combiner combiner;
  int *lg2;

  SparseTable(int n, T *t) : n(n) {
    // Precompute lg2(i) for i in [0..n].
    lg2 = new int[n + 1];
    lg2[0] = -1;
    for (int i = 0; (1 << i) <= n; i++)
      for (int j = (1 << i); j < min(1 << (i + 1), n + 1); j++)
        lg2[j] = i;

    nlog = lg2[n];

    st = new T *[nlog + 1];
    for (int i = 0; i <= nlog; i++)
      st[i] = new T[n];

    for (int j = 0; j < n; j++)
      st[0][j] = t[j];
    for (int i = 1; i <= nlog; i++)
      for (int j = 0; j + (1 << (i - 1)) < n; j++)
        st[i][j] = combiner(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
  }

  T query(int l, int r) {
    if (l > r) {
      eprintf("Error: sparse table query (L, R) = (%d, %d).\n", l, r);
      exit(1);
    }

    l = clamp(l, 0, n - 1);
    r = clamp(r, 0, n - 1);

    int len = lg2[r - l + 1];
    T val = st[len][l];
    l += 1 << len;

    if (l <= r)
      val = combiner(val, query(l, r));

    return val;
  }
};

template <class T> struct SparseTableCombinerSample {
  const T operator()(const T &a, const T &b) { return a + b; }
};

} // namespace DS

#pragma endregion template

int a[100005];

template <class T> struct STCombiner {
  const T operator()(const T &a, const T &b) { return gcd(a, b); }
};

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

  int n;
  cin >> n;
  for (int i = 0; i < n; i++)
    cin >> a[i];

  DS::SparseTable<int, STCombiner<int>> st(n, a);

  int ans = 1;
  for (int i = 0; i < n; i++) {
    if (i == 0)
      ans = max(ans, st.query(1, n - 1));
    else if (i == n - 1)
      ans = max(ans, st.query(0, n - 2));
    else
      ans = max(ans, gcd(st.query(0, i - 1), st.query(i + 1, n - 1)));
  }

  cout << ans << endl;
}

Measured memory_bytes: 7424