Go: package main

import "fmt"

func gcd(x, y int64) int64 {
	for y != 0 {
		r := x % y
		x = y
		y = r
	}
	return x
}

func lcm(x, y int64) int64 {
	return x / gcd(x, y) * y
}

func main() {
	for {
		var a, b int64

		fmt.Scanf("%d %d", &a, &b)

		if a == 0 && b == 0 {
			break
		}

		fmt.Printf("%d %d\n", gcd(a, b), lcm(a, b))
	}
}

C++: #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>

using namespace std;

#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif

#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount

#define rep(i, n) for (int i = 0; i < n; ++i)

template <class T> void max_swap(T& a, const T& b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T& b) { a = min(a, b); }

typedef long long ll;
typedef pair<int, int> pint;

const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };


template <class T>
T gcd(T a, T b)
{
	if (a < b) return gcd(b, a);
	if (b) return gcd(b, a % b);
	else return a;
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }

int main()
{
	int a, b;
	while (~scanf("%d%d", &a, &b))
		printf("%d %d\n", gcd(a, b), lcm(a, b));
}

C++: #include <iostream>
using namespace std;

int main () {
    int a, b, c, d, e, f, g, l;
    cin >> a >> b;
    c = e = a; d = f = b;
    while(1) {
        if(a>b) {
            a %= b;
            if(b==0) {g =b; break;}
        }
        else if(a<b) {
            b %= a;
            if(a==0) {g= a; break;}
        }
    }
    while(1) {
        if(c>d) d += f;
        else if(c<d) c += e;
        if(c == d) l = c;
    }
    cout << g << " " << l << endl;
}

C++: #include <iostream>
#define ll long long
using namespace std;
ll gcd(ll a,ll b)
{
	return b==0 ? a :gcd(b,a%b);
}
int main()
{
	ll x, y;
	while(~scanf("%I64d%I64d",&x,&y))
	{
		ll ans=gcd(x,y);
		printf("%I64d %I64d\n",ans,x/ans*y);
	}
}

C++: #include<iostream>
using namespace std;
int euclid(int a,int b) {
  if(a<b) {
    int tmp=a;
    a=b;
    b=tmp;
  }
  if(a%b==0) return b;
  return euclid(b,a%b);
}

int main() {
  int a=0;
  int b=0;
  while(cin>>a>>b) {
    int n=euclid(a,b);
    cout<<n<<" "<<(a*b)/n<<endl;
  }
  return 0;
}

C++: #include <iostream>
#include <sstream>
//#include <fstream>

using namespace std;

int gcd (int a, int b)
{
	if (a > b ){
		swap (a, b );
	} // end if
	while (b % a != 0 ){
		b = b % a;
		if (a > b ){
			swap (a, b );
		} // end if
	} // end while

	return a;
}

int lcm (int a, int b )
{
	int res = a / gcd (a, b );
 	res *= b;

	return res;
}

int main()
{
//	cut here before submit 
//	freopen("testcase.gl", "r", stdin);
	string str = "";

	while (getline (cin, str ) ) {
		int a, b;
		stringstream ss (str );
		ss >> a >> b;
		cout << gcd (a, b ) << ' ' << lcm (a, b ) << endl;
	} // end for

	return 0;
}

C++: #include <iostream>
#include <cstdio>
using namespace std;

int gcd(int a, int b){

int p,q,r;

if(a<b){p=b;b=a;a=p;

}

while((r=b%a)!=0){
   q=b/a;
   b=a;
   a=r;
   }
   return a;

int main(void)
{    int a, b;
    while(cin >> a >> b) {
      int lcm = a/gcd(a,b)*b;
      cout << gcd(a,b) << " " << lcm << endl;
    }
    return 0;
}

C++: #include <iostream>

int  main() {

//?????§??¬?´???° =????????????????????????????????????
/*(1) a ??? b ??§???????????????????????? r ?????\????????????
???(2) r ??? 0 ?????? b ????????§??¬?´???°??§?????????????????????????????????
???(3) ????????§????????¨????????°a = b?????°b = r ??¨?????? (1) ???????????????????????????*/

//????°???¬?????° =???a*b???/???a??¨b????????§??¬?´???°?????§?±?????????????
	int a = 0, b = 0, swap, kp,num = 1,osu;
	std::cin >> a >> b;
	if (b >= a) { swap = a; a = b; b = swap; }


	while (num) {
		kp = a%b;
		if (kp == 0) { std::cout << b; num = 0; osu = a*b / kp;
		std::cout << " " << osu << std::endl;
		}
		else { a = b; b = kp; }
	}

	
}

C++: #include<iostream>
using namespace std;
int a=0;
int b=0;
long int c=0;
int n,m;
void koyaku(int i , int j)
{
  if(i == j)return ;
  if(i < j)
    {
      int x = i;
      i = j;
      j = x;
    }

  a = i - j;

  while(1)
    {
      b = j - a;
      
      if(a == b)return ;
    }
}

void kobai(int i , int j)
{
  if(i == j)return ;

  c = i * j / a;
}

int main()
{
  while(scanf("%d %d",&n,&m) != EOF)
    {
      koyaku(n,m);
      kobai(n,m);
      cout << a << " " << c << endl;
    }
}

C++: #include<stdio.h>
#include<string.h>

int GCD(int x,int y)
{
  if(y==0)
    return x;
  return GCD(y,x%y);
}

int LCM(int x,int y)
{
  return x * y / GCD(x,y);
}



int main(void)
{
  int a,b;
  while(scanf("%d %d",&a,&b) != EOF)
    {
      if(a<b){
	int k = b;
	b = a;
	a = k;
      }
      printf("%d %d\n",GCD(a,b),LCM(a,b));
    }
}

C++: #include <iostream>
using namespace std;

unsigned long long int gcd(unsigned long long int a, unsigned long long int b)
{
	if(b == 0)
	{
		return(a);
	}
	return gcd(b, a % b);
}

void solve()
{
	unsigned long long int a;
	while(cin >> a)
	{
		unsigned long long int b;
		cin >> b;
		if(a < b)
		{
			unsigned long long int temp = a;
			a = b;
			b = temp;
		}
		unsigned long long int g = gcd(a, b);
		unsigned long long int lcm = a * b / g;
		cout << g << " " << lcm << endl;
	}
}

int main()
{
	solve();
	return(0);
}

C++: #include <iostream>
using namespace std;

int gcd(int m, int n) {
    if (m == 0 || n == 0) {
        return 0;
    }
    while (m != n) {
        if (m > n) {
            m = m - n;
        } else {
            n = n - m;
        }
    }
    return m;
}

int main() {
    int a, b;
    while (cin >> a >> b) {
        int g = gcd(a, b);
        int l = a / g * b;
        cout << g << " " << l << endl;
    }
}

C++: #include<bits/stdc++.h>
#define int long long
using namespace std;
int gcd(int a,int b){
	if(b==0)return a;
	return gcd(b,a%b);
	}
signed main()
{
	int a,b;
	while(cin>>a>>b){
	 cout<<gcd(a,b)<<" "<<a*b/gcd(a,b)<<endl;
		}
	}

C++: #include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int main(){
	long long a,b,s,m,ta,tb,tmp;
	while(cin>>a>>b){
	ta=a,tb=b;
	s=0,m=0;
	if(a<b)swap(a,b);
	if(a==0||b==0){
	
	}
	else 
	while(true){
		tmp=a;
		a=b;
		b=tmp%a;
		if(a%b==0){
			m=b;
			break;
		}
		if(a<b){
		//cout<<a<<" "<<b<<endl;
		m=1;
		break;
		}
		if(a==0||b==0)break;
	}
		
		s=(ta*tb)/m;
		cout<<m<<" "<<s<<endl;
	}
}

C++: # include <iostream>

unsigned long a, b;

unsigned long gcd(unsigned long x, unsigned long y) {
	return (y == 0) ? x : gcd(y, x%y);
}

unsigned long  lcm(unsigned long x, unsigned long y, unsigned long g) {
	return x / g*y;
}

int main() {
	while (1) {
		if (std::cin.eof())
			break;
		std::cin >> a >> b;
		unsigned long res1, ans;
		if (a < b)
			res1 = gcd(b, a);
		else
			res1 = gcd(a, b);
		ans = lcm(a, b, res1);
		std::cout << res1 <<' '<< ans << std::endl;
	}
	return 0;
}

C++: #include <iostream>
#include <algorithm>
using namespace std;

long GCD(long, long);
long LCM(long, long);

long gcd, lcm;

int main(){
	long a, b;
	while(cin >> a >> b){
		if(a < b)
			swap(a, b); // a > b
		gcd = GCD(a, b);
		lcm = LCM(a, b);
		cout << gcd << " " << lcm << endl;
	}
	return 0;
}

long GCD(long a, long b){
	if(b == 0)
		return a;
	else
		return GCD(b, a%b);
}

long LCM(long a, long b){
	return a*b/gcd;
}