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 Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::*;
use std::cmp;

fn gcd(a: u32, b: u32) -> u32 {
    if a < b {
        if b % a == 0 {
            return a;
        }
        return gcd(b % a, a);
    }
    if a % b == 0 {
        return b;
    }
    gcd(a, a % b)
}


fn solve(n: usize, mut a: Vec<u32>) -> u32 {
    a.sort();
    let mut min:u32 = a[0];
    let mut min_index = 0;
    let mut min_count:u32 = 1;
    for i in 1 .. n {
        let k = gcd(a[0],*a.get(i).unwrap());
        if min > k {
            min = k;
            min_index = i;
            min_count = 1;
        }
        else if min == k {
            min_count += 1;
        }
    }
    let mut min_0:u32 = a[1];
    for i in (2 .. n) {
        let k = gcd(a[1], *a.get(i).unwrap());
        if min_0 > k {
            min_0 = k;
        }
    }
    if min_count > 1 {
        return min_0;
    }
    let mut min_k:u32 = a[0];
    for i in (1 .. n) {
        if i == min_index {
            continue;
        }
        let k = gcd(a[0],*a.get(i).unwrap());
        if min_k > k {
            min_k = k;
        }
    }
    cmp::max(min_0, min_k)
}

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    let n: usize = iter.next().unwrap().parse().unwrap();
    let a: Vec<u32> = (0..n)
        .map(|_| {
            iter.next().unwrap().parse().unwrap()
        }).collect();

    println!("{}", solve(n, a));
}