#include <iostream>
#include <queue>
#include <map>
#include <cmath>
#include <algorithm>
#include <queue>
#include <cstdarg>
#include <set>
#include <limits>
#include <iomanip>
#include <stack>


using namespace std;
#define INF 2e9 + 9
#define MOD 1000000007
#define ALL(v) v.begin() , v.end()
#define Int int64_t
#define pll pair<Int,Int>
template<class T> using pql = priority_queue<T, vector<T>>;
template<class T> using pq = priority_queue<T, vector<T>, greater<T>>;
#define ll(n) Int n; cin >> n;
#define LL(...) Int __VA_ARGS___; cin >> __VA_ARGS___;
#define OUT(...) cout << __VA_ARGS___;
#define RP(n, i, s) for(Int i = s ;i < n ;i++)
#define REP(n, i) for (Int i = 0; i < n; i++)
#define REPe(n, i) for (Int i = 1; i <= n; i++)
#define RPe(n, i, s) for (Int i = s; i <= n; i++)
#define upd_max(maxer, updater) if (maxer < updater) maxer = updater;
#define upd_min(miner, updater) if (miner > updater) miner = updater;

void ansYes(bool flag) {
    if (flag) cout << "Yes" << endl; else cout << "No" << endl;
}

void ansYES(bool flag) {
    if (flag) cout << "YES" << endl; else cout << "NO" << endl;
}

struct node {
    Int to;
    Int length;
};


vector<Int> divisor(Int n) {
    vector<Int> ret;
    for (Int i = 1; i * i <= n; i++) {
        if (n % i == 0) {
            ret.push_back(i);
            if (i * i != n) ret.push_back(n / i);
        }
    }
    return (ret);
}

class Graph {
protected:
    int n;
    vector<Int> prev;
    vector<Int> minD;
    vector<vector<node>> ker;
public:
    Graph(Int N) : n(N), prev(N), minD(N), ker(N) {}

    void addEdge(Int from, Int next, Int cost) {
        ker.at(from).push_back({next, cost});
        ker.at(next).push_back({from, cost});
    }

    void addDirectedEdge(Int from, Int next, Int cost) {
        ker.at(from).push_back({next, cost});
    }

    void dijkstra(Int s) {
        REP(n, i) {
            minD.at(i) = INF;
        }
        minD.at(s) = 0;
        priority_queue<pll, vector<pll >, greater<>> que;
        que.push({0, s});
        while (!que.empty()) {
            auto z = que.top();
            que.pop();
            int v = z.second;
            if (minD[v] < z.first) continue;
            REP(ker.at(v).size(), i) {
                node n = ker.at(v).at(i);
                if (minD[n.to] > minD[v] + n.length) {
                    minD[n.to] = minD[v] + n.length;
                    que.push({minD[n.to], n.to});
                }
            }
        }
    }

    bool bellmanford(Int s) {
        bool flag = false;
        REP(n, i) {
            minD.at(i) = INF;
        }
        minD.at(s) = 0;
        REP(n - 1, i) {
            REP(n, k) {
                for (auto z: ker.at(k)) {
                    if (minD[k] != INF && minD[z.to] > minD[k] + z.length) {
                        minD[z.to] = minD[k] + z.length;
                    }
                }
            }
        }

        REP(n, k) {
            for (auto z: ker.at(k)) {
                if (minD[k] != INF && minD[z.to] > minD[k] + z.length) {
                    minD[z.to] = minD[k] + z.length;
                    flag = true;
                }
            }
        }
        return flag;
    }

    Int getD(Int x) {
        return minD[x];
    }

    Int putD(Int x, string sep = "\n") {
        if (minD[x] == INF) {
            cout << "INF" << sep;
        } else {
            cout << minD[x] << sep;
        }
        return minD[x];
    }
};


/*
vector<vector<int>> to;
vector<int> flag;
vector<int> c;


Int dfs(int from, int mae) {
    flag[from] = 1;
    Int mini = 0;
    for (auto next : to[from]) {
        if (next == mae) continue;
        if (flag[next] == 1) {
            return -1;
        } else {
            mini = min(mini, dfs(next, from));
        }
    }
    return mini;
}*/

int dx8[8] = {0, -1, -1, -1, 0, 1, 1, 1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};

int dx[4] = {0, -1, 0, 1};
int dy[4] = {-1, 0, 1, 0};

struct datas {
    Int max;
    Int size;
};

class ContainChecker {
protected:
    Int minx, miny, maxx, maxy;
public:
    ContainChecker(Int minx, Int miny, Int maxx, Int maxy) : minx(minx), miny(miny), maxx(maxx), maxy(maxy) {};

    bool in(Int x, Int y) {
        return (minx <= x && miny <= y && x <= maxx && y <= maxy);
    }
};

Int getHead(Int n) {
    while(n / 10 > 0){
        n /= 10;
    }
    n %= 10;
    return n;
}


int main(void) {
    Int n;
    cin >> n;
    vector<Int> a(n);
    vector<Int> left(n);
    vector<Int> right(n);
    REP(n,i){
        cin >> a.at(i);
    }
    left.at(0) = a.at(0);
    right.at(n-1) = a.at(n-1);
    REPe(n-1,i){
        left.at(i) = __gcd(left.at(i-1) , a.at(i));
    }
    for (int i = n-2;i>0;i--){
        right.at(i) = __gcd(right.at(i+1),a.at(i));
    }
    Int maxer = 0;
    upd_max(maxer,right.at(1));
    upd_max(maxer,left.at(n-2));
    for (Int i = 1;i < n-1;i++){
        upd_max(maxer,__gcd(right.at(i+1),left.at(i-1)));
    }
    cout << maxer << endl;
}




Measured memory_bytes: 2560