Problem:
GCD and LCM

Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given a and b.

Input

Input consists of several data sets. Each data set contains a and b separated by a single space in a line. The input terminates with EOF.

Constraints

0 < a, b ≤ 2,000,000,000

LCM(a, b) ≤ 2,000,000,000

The number of data sets ≤ 50

Output

For each data set, print GCD and LCM separated by a single space in a line.

Sample Input

8 6
50000000 30000000

Output for the Sample Input

2 24
10000000 150000000

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp10
{
    class Program
    {
        static void Main(string[] args)
        {
            Calc calc = new Calc();

            string str;
            List<int[]> num = new List<int[]>();

            int gcd, lcm;

            while (!((str = Console.ReadLine()) == null))
            {
                num.Add(str.Split(' ').Select(int.Parse).ToArray());
            }

   

            for (int i = 0; i < num.Count(); i++)
            {
                int[] num2 = { num[i][0], num[i][1] };

                gcd = calc.EucledeanAlgorithm(num[i]);
                lcm = calc.LCM(num2, gcd);

                Console.WriteLine("{0} {1}", gcd, lcm);
            }
        }
    }

    class Calc
    {
        int r;
        int[] num;

        internal int EucledeanAlgorithm(int[] number)
        {
            int gcd;
            num = number;
            r = 1;

            while (r != 0)
            {
                num = Remainder();
            }
            gcd = num[0];

            return gcd;
        }

        internal int[] Remainder()
        {
            int a, b;

            if (num[0] >= num[1])
            {
                a = num[1]; b = num[0];
            }
            else
            {
                a = num[0]; b = num[1];
            }
            r = b - (b / a) * a;

            num[0] = a;  num[1] = r;

            return num;
        }

        internal int LCM(int[] num,int gcd)
        {
            int lcm;
            lcm = (num[0] / gcd) * (num[1] / gcd) * gcd;

            return lcm;
        }
    }
}