using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

partial class Solver
{
    static public long Gcd(long s, long t)
    {
        return t != 0 ? Gcd(t, s % t) : s;
    }

    public class SegmentTree<TNodeValue> where TNodeValue : struct
    {
        readonly int n;
        readonly TNodeValue?[] node;
        readonly Func<TNodeValue, TNodeValue, TNodeValue> MergeMethod;
        static int Left(int p) { return p * 2 + 1; }
        static int Right(int p) { return p * 2 + 2; }

        public SegmentTree(int _n, Func<int, TNodeValue> create, Func<TNodeValue, TNodeValue, TNodeValue> merge)
        {
            n = 1;
            while (n < _n) n *= 2;
            node = new TNodeValue?[2 * n];

            MergeMethod = merge;

            // 葉の初期化
            for (int i = 0; i < n; i++)
            {
                node[i + n - 1] = i < _n ? create(i) : (TNodeValue?)null;
            }
            // 枝の初期化
            for (int i = n - 2; i >= 0; i--)
            {
                node[i] = Merge(node[Left(i)], node[Right(i)]);
            }
        }

        TNodeValue? Merge(TNodeValue? left, TNodeValue? right)
        {
            if (left == null && right == null) return null;
            if (left == null) return right;
            if (right == null) return left;
            return MergeMethod(left.Value, right.Value);
        }

        public void Update(int index, TNodeValue val)
        {
            int p = index + n - 1;
            node[p] = val;
            while (p > 0)
            {
                p = (p - 1) / 2;
                node[p] = Merge(node[Left(p)], node[Right(p)]);
            }
        }

        public TNodeValue? Query(int begin, int end, int k, int l, int r)
        {
            if (r <= begin || end <= l) return null;
            if (begin <= l && r <= end) return node[k];
            int mid = (l + r) / 2;
            var nodeL = Query(begin, end, Left(k), l, mid);
            var nodeR = Query(begin, end, Right(k), mid, r);
            return Merge(nodeL, nodeR);
        }

        public TNodeValue Query(int begin, int end)
        {
            return Query(begin, end, 0, 0, n).Value;
        }
    };

    public void Run()
    {
        var N = ni();
        var A = ni(N);

        var tree = new SegmentTree<int>(N, index => A[index], (x, y) => (int)Gcd(x, y));

        var ans = Math.Max(tree.Query(0, N - 1), tree.Query(1, N));

        for (int i = 1; i < N - 1; i++)
        {
            ans = Math.Max(ans, (int)Gcd(tree.Query(0, i), tree.Query(i + 1, N)));
        }

        cout.WriteLine(ans);
    }
}


// PREWRITEN CODE BEGINS FROM HERE
partial class Solver : Scanner
{
    public static void Main(string[] args)
    {
        new Solver(Console.In, Console.Out).Run();
    }

    TextReader cin;
    TextWriter cout;

    public Solver(TextReader reader, TextWriter writer)
        : base(reader)
    {
        this.cin = reader;
        this.cout = writer;
    }
    public Solver(string input, TextWriter writer)
        : this(new StringReader(input), writer)
    {
    }

    public int ni() { return NextInt(); }
    public int[] ni(int n) { return NextIntArray(n); }
    public long nl() { return NextLong(); }
    public long[] nl(int n) { return NextLongArray(n); }
    public double nd() { return NextDouble(); }
    public string ns() { return Next(); }
}

public class Scanner
{
    private TextReader Reader;
    private Queue<String> TokenQueue = new Queue<string>();
    private CultureInfo ci = CultureInfo.InvariantCulture;

    public Scanner()
        : this(Console.In)
    {
    }

    public Scanner(TextReader reader)
    {
        this.Reader = reader;
    }

    public int NextInt() { return Int32.Parse(Next(), ci); }
    public long NextLong() { return Int64.Parse(Next(), ci); }
    public double NextDouble() { return double.Parse(Next(), ci); }
    public string[] NextArray(int size)
    {
        var array = new string[size];
        for (int i = 0; i < size; i++) array[i] = Next();
        return array;
    }
    public int[] NextIntArray(int size)
    {
        var array = new int[size];
        for (int i = 0; i < size; i++) array[i] = NextInt();
        return array;
    }

    public long[] NextLongArray(int size)
    {
        var array = new long[size];
        for (int i = 0; i < size; i++) array[i] = NextLong();
        return array;
    }

    public String Next()
    {
        if (TokenQueue.Count == 0)
        {
            if (!StockTokens()) throw new InvalidOperationException();
        }
        return TokenQueue.Dequeue();
    }

    public bool HasNext()
    {
        if (TokenQueue.Count > 0)
            return true;
        return StockTokens();
    }

    private bool StockTokens()
    {
        while (true)
        {
            var line = Reader.ReadLine();
            if (line == null) return false;
            var tokens = line.Trim().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            if (tokens.Length == 0) continue;
            foreach (var token in tokens)
                TokenQueue.Enqueue(token);
            return true;
        }
    }
}


Measured memory_bytes: 31068