Problem:
Score : 300 points

Problem Statement

There are N integers, A_1, A_2, ..., A_N, written on the blackboard.

You will choose one of them and replace it with an integer of your choice between 1 and 10^9 (inclusive), possibly the same as the integer originally written.

Find the maximum possible greatest common divisor of the N integers on the blackboard after your move.

Constraints

All values in input are integers.

2 \leq N \leq 10^5

1 \leq A_i \leq 10^9

Output

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the maximum possible greatest common divisor of the N integers on the blackboard after your move.

Sample Input 1

3
7 6 8

Sample Output 1

2

If we replace 7 with 4, the greatest common divisor of the three integers on the blackboard will be 2, which is the maximum possible value.

Sample Input 2

3
12 15 18

Sample Output 2

6

Sample Input 3

2
1000000000 1000000000

Sample Output 3

1000000000

We can replace an integer with itself.

Solution in Ruby (2.3.3) (judge verdict: Accepted)

class SegmentTree
  ROOT = 1
  private_constant :ROOT

  attr_reader :size

  def initialize(n, x = 0)
    @size = 1
    @size *= 2 while @size < n
    @sum = Array.new(2 * @size){x}
    @parent = Array.new(2 * @size)
    @lchild = Array.new(2 * @size)
    @rchild = Array.new(2 * @size)
    (2 * @size).times do |i|
      @parent[i] = i / 2
      @lchild[i] = i * 2
      @rchild[i] = i * 2 + 1
    end
  end

  def update(i, v)
    i += @size
    @sum[i] = v
    until i == ROOT
      i = @parent[i]
      @sum[i] = @sum[@lchild[i]].gcd(@sum[@rchild[i]])
    end
  end

  def sum(l, r)
    sum_dfs(l, r, ROOT, 0, @size)
  end
  def sum_dfs(a, b, i, l, r)
    return 0       if b <= l || r <= a
    return @sum[i] if a <= l && r <= b
    m = (l + r) / 2
    sum_dfs(a, b, @lchild[i], l, m).gcd(sum_dfs(a, b, @rchild[i], m, r))
  end
end

N=gets.to_i
A=gets.split.map &:to_i

segtree = SegmentTree.new(N)
A.each.with_index do |a, i|
  segtree.update(i, a)
end
res = 0
N.times do |i|
  l = i.zero? ? 0 : segtree.sum(0, i)
  r = i+1==N  ? 0 : segtree.sum(i+1, N)
  d = l.gcd(r)
  res = [res, d].max
end
p res