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::fs;
use std::io::{stdin, Read};

macro_rules! parse {
    ($it: ident) => {
        $it.next().unwrap().parse().unwrap()
    };
    ($it: ident,2) => {
        (parse!($it), parse!($it))
    };
    ($it: ident,3) => {
        (parse!($it), parse!($it), parse!($it))
    };
    ($it: ident,4) => {
        (parse!($it), parse!($it), parse!($it), parse!($it))
    };
    ($it: ident, $n: expr) => {
        (&mut $it).take($n).map(|e| e.parse().unwrap()).collect();
    };
}

fn gcd(a: usize, b: usize) -> usize {
    match b {
        0 => a,
        _ => gcd(b, a % b),
    }
}

fn solve(s: &str) {
    let mut it = s.split_whitespace();
    let n = parse!(it);
    let a: Vec<usize> = parse!(it, n);
    let b = (0..(n - 1))
        .map(|i| gcd(a[i], a[i + 1]))
        .collect::<Vec<_>>();
    let mut c = b.iter().enumerate().collect::<Vec<_>>();
    c.sort_by(|&(_, &x), &(_, &y)| x.cmp(&y));
    let i = c[0].0;
    let a0 = a
        .iter()
        .enumerate()
        .filter(|&(j, &x)| j != i)
        .map(|(_, &x)| x)
        .collect::<Vec<_>>();
    let a1 = a
        .iter()
        .enumerate()
        .filter(|&(j, &x)| j != i + 1)
        .map(|(_, &x)| x)
        .collect::<Vec<_>>();
    let vecgcd = |x: Vec<usize>| x.iter().fold(x[0], |y, z| gcd(y, *z));
    println!("{}", std::cmp::max(vecgcd(a0), vecgcd(a1)));
}

fn test() {
    let mut f = fs::File::open("foo.txt").unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();
    solve(&s);
}

fn main() {
    let mut s = String::new();
    stdin().read_to_string(&mut s).unwrap();
    solve(&s);
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_main() {
        test();
    }
    #[test]
    fn test_input() {
        let s = "
        ";
        solve(s);
    }
}