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 Kotlin (1.0.0) (judge verdict: Runtime Error)

import java.util.*

fun main(args: Array<String>) {
    val n = Integer.parseInt(readLine() ?: "0")
    val alist = readLine()?.split(" ") ?: listOf()
    val a = alist.map{Integer.parseInt(it)}.distinct()
    when(a.size) {
      0 -> {
        println("0")
      }
      1 -> {
        println(a[0])
      }
      2 -> {
        if(alist[0] > alist[1]) {
          println(alist[0])
        } else {
          println(alist[1])
        }
      }
      else -> {
        var ans = 0
        for(i in 1..n-1) {
          val l = a.take(i)
          val r = a.takeLast(a.size - i - 1)
          val lgcd = solve(l)
          val rgcd = solve(r)
          var m = when {
            lgcd == 0 -> rgcd
            rgcd == 0 -> lgcd
            else -> {
              solve(listOf(lgcd, rgcd))
            }
          }
          if(ans < m) ans = m
        }
        println(ans)
      }
    }
}

fun solve(numList: List<Int>): Int {
  var newList = numList.distinct().sorted().filter { it != 0 } as MutableList
  var r: Int = 0
  if(newList.size == 0) return 0
  if(newList.size == 1) return newList[0]
  while (newList.count() > 1) {
    r = newList[0]
    newList = newList.takeLast(newList.count() - 1).map {it % newList[0]} as MutableList
    newList.add(r)
    newList = newList.distinct().sorted().filter { it != 0 } as MutableList<Int>
  }
  return r
}