Problem:
Score : 300 points

Problem Statement

We have N clocks. The hand of the i-th clock (1≤i≤N) rotates through 360° in exactly T_i seconds.

Initially, the hand of every clock stands still, pointing directly upward.

Now, Dolphin starts all the clocks simultaneously.

In how many seconds will the hand of every clock point directly upward again?

Constraints

1≤N≤100

1≤T_i≤10^{18}

All input values are integers.

The correct answer is at most 10^{18} seconds.

Input

Input is given from Standard Input in the following format:

N
T_1
:
T_N

Output

Print the number of seconds after which the hand of every clock point directly upward again.

Sample Input 1

2
2
3

Sample Output 1

6

We have two clocks. The time when the hand of each clock points upward is as follows:

Clock 1: 2, 4, 6, ... seconds after the beginning

Clock 2: 3, 6, 9, ... seconds after the beginning

Therefore, it takes 6 seconds until the hands of both clocks point directly upward.

Sample Input 2

5
2
5
10
1000000000000000000
1000000000000000000

Sample Output 2

1000000000000000000

Solution in C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

//
// ABC070C
// URL : https://atcoder.jp/contests/abc070/tasks/abc070_c
// 
using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;

namespace AtCoder
{
    class ABC070C
    {
        static void Main(string[] args)
        {
            preprocess();

            // 整数の入力
            long N = long.Parse(Console.ReadLine());

            var TList = new Dictionary<int, long>((int)N);
            for(int i = 0; i < N; ++i)
            {
                long x = long.Parse(Console.ReadLine());
                //重複を含めない
                if (TList.ContainsValue(x) == false)
                {
                    TList.Add(i, x);
                }
            }
            var ans = Solve(N, TList);

            Console.WriteLine(ans.ToString());
            Console.Out.Flush();
        }

        static ulong Solve(long N, Dictionary<int, long> TList)
        {
            //TListにある数の最小公倍数を求める
            ulong ans = (ulong)TList[0];
            for(int i = 1; i < TList.Count; ++i)
            {
                ans = Lcm(ans, (ulong)TList[i]);
            }
            return ans;
        }

        //---------------------------------------------------------------------------------
        /// <summary>
        /// 
        /// </summary>
        public static void preprocess()
        {
            //出力高速化
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(sw);
        }


        /// <summary>
        /// 与えられた数が素数かどうかを計算する
        /// </summary>
        /// <param name="num">対象数</param>
        /// <returns>true:素数, false:素数ではない(合成数)</returns>
        public static bool isPrime(int num)
        {
            if (num < 2) return false;
            else if (num == 2) return true;
            else if (num % 2 == 0) return false;

            double sqrtNum = Math.Sqrt(num);
            for (int i = 3; i <= sqrtNum; i += 2)
            {
                if (num % i == 0)
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// 順列mPnを計算する
        /// </summary>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public static long Permutation(long m, long n)
        {
            long ret = 1;
            for(var i = 0; i < n; ++i)
            {
                ret *= m - i;
            }
            return ret;
        }
        /// <summary>
        /// 組み合わせmCnを計算する
        /// </summary>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public static long Combination(long m, long n)
        {
            if(m == n || n == 0)
            {
                return 1;
            }
            long ans = 1;
            for(var i = 0; i <= n; ++i)
            {
                ans *= (m - i + 1) / i;
            }
            return ans;
        }

        static ulong Gcd(ulong m, ulong n)
        {
            if (n == 0) return m;
            return Gcd(n, m % n);
        }

        static ulong Lcm(ulong m, ulong n)
        {
            var gcd = Gcd(m, n);
            return (m * n) / gcd;
        }
    }
}