Go: package main

import "fmt"

func main() {
	for {
		var x, y int
		fmt.Scanf("%d %d", &x, &y)
		if x < y {
			rep := x
			x, y = y, rep
		}
		gcd := x % y
		lcm := x * y
		for gcd != 0 {
			x, y, gcd = y, gcd, x%y
		}
		fmt.Printf("%d %d\n", y, lcm/y)
	}
}

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

int getGCD(int a, int b) { return b ? getGCD(b, a%b) : a; }
int main() {
	int a, b, gcd;
	while (cin >> a >> b) {
		gcd = getGCD(a, b);
		cout << gcd << " " << (long long)a*b/gcd << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <cmath>
#include <algorithm>
#include <string>
#include <stdio.h>
using namespace std;
int gcd(int x,int y){
    if(x<y)swap(x,y);
    int r=1;
    while (r) {
        r=x%y;
        x=y;
        y=r;
    }
    return x;
    
}
int main() {
    int a,b;
    while (cin >> a >> b) {
        cout << gcd(a,b)<< " "<< (long long) a*b/gcd(a, b)<<endl;
    }
}

C++: #include<iostream>
using namespace std;
int GCD( int m, int n )
{
	
	if ( ( 0 == m ) || ( 0 == n ) )
		return 0;
	
	
	while( m != n )
	{
		if ( m > n ) m = m - n;
		else         n = n - m;
	}
	return m;
}
int LCM( int m, int n )
{
	
	if ( ( 0 == m ) || ( 0 == n ) )
		return 0;
	
	return ((m / GCD(m, n)) * n); 
}
int main()
{
	int n,m;
	while(cin>>n>>m){
		cout<<GCD(n,m)<<" "<<LCM(n,m)<<endl;
	}
}

C++:  #include <bits/stdc++.h>
using namespace std;
int main(){
	long long a,b;
	while(cin >> a >> b){
		cout << __gcd(a,b) << ' ' << a*b/__gcd(a,b) << endl;
	}
	return 0;
}

C++: #include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;

#define EACH(i,a) for (auto& i : a)
#define FOR(i,a,b) for (ll i=(a);i<(b);i++)
#define RFOR(i,a,b) for (ll i=(b)-1;i>=(a);i--)
#define REP(i,n) for (ll i=0;i<(n);i++)
#define RREP(i,n) for (ll i=(n)-1;i>=0;i--)
#define debug(x) cout<<#x<<": "<<x<<endl
#define pb push_back
#define ALL(a) (a).begin(),(a).end()

const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);

template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
	EACH(x,vec) is >> x;
	return is;
}
/*
template<class... T>
ostream& operator<<(ostream& os, tuple<T...>& t) {
	for (size_t i = 0; i < tuple_size< tuple<T...> >::value; ++i) {
		if (i) os << " ";
		os << get<0>(t);
	}
	return os;
}
*/
template<typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
	REP(i,vec.size()) {
		if (i) os << " ";
		os << vec[i];
	}
	return os;
}
template<typename T>
ostream& operator<<(ostream& os, vector< vector<T> >& vec) {
	REP(i,vec.size()) {
		if (i) os << endl;
		os << vec[i];
	}
	return os;
}

ll gcd(ll a, ll b) {
	if (b == 0) return a;
	return gcd(b, a%b);
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	ll a, b;
	while ( cin >> a >> b ) {
		ll g = gcd(a, b);
		cout << g << " " << a/g*b << endl;
	}
}

C++: #include <stdio.h>
#include <iostream>
#include <math.h>

int u(int a, int b);
int l(int a, int b);

int main(){
  int a, b;
  int gcd, lcm;
  
  while(scanf("%d", &a)!=EOF){
    scanf("%d", &b);
    gcd = u(a, b);
    lcm = l(a, b);
    std::cout << gcd << " " << lcm << std::endl;
  }
  
  return 0;
}

int u(int a, int b){
  while(a==1 || b==1){
    if(a>=b){
      a %= b;
    }else{
      b %= a;
    }
  }
  
  if(a==1) return b;
  else     return a;
}

int l(int a, int b){
  int i = 2;
  
  while(1){
    if(a%i==0){
      if(b%i==0) return i;
      else i++;
    }else{
      i++;
    }
  }
}

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

int gcd(int a, int b) {
return a % b ? gcd(b, a % b) : b;
}
int lcm(int a, int b) {
return a / gcd(a,b) * b;
}

int main() {
int a, b;
while(con >> a >> b) {
cout << gcd(a,b) << " " << lcm(a,b) << endl;
}

C++: #include <cstdio>
int gcd(int a,int b) {
	return b?gcd(b,a%b):a;
}
int lcm(int a,int b,int g) {
	return a/g*b;
}
int main() {
	int a,b,g;
	while(scanf("%d %d",&a,&b)!=EOF) {
		g=gcd(a,b);
		printf("%d %d\n",g,lcm(a,b,g));
	}
}

C++: #include <iostream>
using namespace std;
int gcd(int x,int y){
	if(x==0)return y;
	return gcd(y%x,x);
}
int main(){
	while(!cin.eof()){
		int a,b;
		cin>>a>>b;
		int g=gcd(a,b);
		cout<<g<<' '<<a/g*b<<endl;
	}
	return 0;
}

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

int main(){
  int a, b, x, y, q, r=1;
  while (cin >> a >> b){
    x=a; y=b;
    while (r>0){
      q=x/y; r=x%y;
      if (r>0){
	x=y; y=r;
      }
    }

    cout << y << " " << a/y*b << endl;
    r=1;
  }
  return 0;
}

C++: #include<iostream>
using namespace std;
int main()
{
	int a,b,c,rest;
	while(1){
		cin >> a>>b;
		int a2=a,b2=b;

		if(a>b){c=a;a=b;b=c;}
		while((rest=b%a)!=0){
			b=a;
			a=rest;
		}

		cout << a <<" "<< a2/a*b2 << endl;
	}
	return 0;
}

C++: #include<iostream>
using namespace std;
int gcd(int a,int b){
    while(a>0&&b>0){
        if(a>b)
            a%=b;
        else
            b%=a;
    }
    if(a==0)
        return b;
    else
        return a;
}
int main(){
    int a,b;
    while(cin>>a>>b){
        int c=gcd(a,b);
        int lcm=a*b/c;
        cout<<c<<" "<<lcm<<endl;
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

// long long gcd(long long a, long long b) {
//   if (b == 0) return a;
//   return gcd(b, a % b);
// }
//
// long long lcm(long long a, long long b) {
//   return a / gcd(a, b) * b;
// }

int64_t gcd(int64_t a, int64_t b) {
  if (a == 0 || b == 0) return a + b;
  return (a < b ? gcd(a, b - a) : gcd(b, a - b));
}

int64_t lcm(int64_t a, int64_t b) {
  return a / gcd(a, b) * b;
}

int main() {
  int64_t a, b;
  while (cin >> a >> b) {
    cout << gcd(a, b) << " " << lcm(a, b) << endl;
  }
}

C++: 
#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    int a, b;
    while(cin >> a >> b) {
        unsigned long long p = (unsigned long long)a*b;
        int gcd = __gcd(a, b);
        cout << gcd << ' ' << p/gcd << endl;
    }
    return 0;
}

C++: #include <stdio.h>
#include <iostream>
#include <math.h>

int u(int a, int b);
int l(int a, int b);

int main(){
  int a, b;
  int gcd, lcm;
  
  while(scanf("%d", &a)!=EOF){
    scanf("%d", &b);
    gcd = u(a, b);
    lcm = l(a, b);
    std::cout << lcm << " " << gcd << std::endl;
  }
  
  return 0;
}

int u(int a, int b){
  while(a==1 || b==1){
    if(a>=b){
      a %= b;
    }else{
      b %= a;
    }
  }
  
  if(a==1) return b;
  else     return a;
}

int l(int a, int b){
  int i = 2;
  
  while(1){
    if(a%i==0){
      if(b%i==0) return i;
      else i++;
    }else{
      i++;
    }
  }
}

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);
	}
	else
	{
		gcd(b, a % b);
	}
}

unsigned long long int lcm(unsigned long long int a, unsigned long long int b, unsigned long long int g)
{
	return(a * b / g);
}

void solve()
{
	int m, n;
	while(cin >> m >> n)
	{
		int g = gcd(m, n);
		cout << g << " " <<	lcm(m, n, g) << endl;
	}
}

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

C++: #include <iostream>
using namespace std;
int main(){
int a,b;
while(cin>>a>>b){
int max=0,min;
for(int i=a;max==0;i--){
if(a%i==0 && b%i==0){
max=i;}}
min=(a/max)*b;
cout<<max<<" "<<min<<endl;
}
return 0;
}

C++: #include<iostream>
int GCD(int x,int y){
	while(x%y!=0){
		int z=x%y;
		x=y;
		y=z;
	}
	return y;
}
int main(){
	int a=0,b=0;
	while(std::cin>>a>>b){
		std::cout<<GCD(a,b)<<" "<<a*b/GCD(a,b)<<std::endl;
	}
	std::system("pause");
	return 0;
}

C++: #include<cstdio>
typedef long long lolo;
lolo gcd(lolo a, lolo b){
  if(b == 0)
    return a;
  else
    return gcd(b,a%b);
}
void solve(lolo a, lolo b){
  lolo ans = gcd(a,b);
  printf("%lld %lld\n",ans,a / ans * b);
}
int main(){
  lolo a;
  lolo b;
  while(scanf("%lld %lld",&a,&b) != EOF)
    solve(a,b);
}