Go: package main

import "fmt"

func main() {
	var gcdArr, lcmArr [100]int
	var count int
	for {
		var x, y int
		fmt.Scanf("%d %d", &x, &y)
		if x == 0 {
			break
		}
		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
		}
		gcdArr[count] = y
		lcmArr[count] = lcm / y
		count++
	}
	for i := 0; i < count; i++ {
		fmt.Printf("%d %d\n", gcdArr[i], lcmArr[i])
	}
}

C++: //#define _GRIBCXX_DEBUG
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;


// ?????¬???????????¬??????
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion

#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion


// Effective std
#pragma region ESTD
template<typename C, typename T>
constexpr int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F>
constexpr int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T, typename U>
constexpr void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U>
constexpr void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C>
constexpr void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred>
constexpr void sort(C& c, Pred p) { sort(ALL(c), p); }
template<typename C>
constexpr void reverse(C& c) { reverse(ALL(c)); }
#pragma endregion


// ?´???°
#pragma region PRIME
bool is_prime(unsigned n) {
  switch(n) {
    case 0:
    case 1: return false;
    case 2: return true;
  }
  if (n%2==0) return false;
  for (unsigned i=3; i*i<=n; i+=2)
    if (n%i==0) return false;
  return true;
}
#pragma endregion


// ??§??????/?°?????????????
#pragma region TRANSFORM
void mutal_tr(string &s) {
  for(int i=s.size(); i--;) {
    if(islower(s[i])) s[i] = toupper(s[i]);
    else if (isupper(s[i])) s[i] = tolower(s[i]);
  }
}
void to_upper(string &s) { for(int i=s.size(); i--;) s[i] = toupper(s[i]); }
void to_lower(string &s) { for(int i=s.size(); i--;) s[i] = tolower(s[i]); }
#pragma endregion


// ??????
#pragma region SET
template<class T>
set<T> intersection(const set<T>& sa, const set<T>& sb) {
  set<T> ret;
  for(T a : sa) if(sb.find(a) != sb.end()) ret.insert(a);
  return ret;
}
#pragma endregion

// Union Find
#pragma region UF
struct UnionFind {
  vector<int> data;
  UnionFind(int size) : data(size, -1) {}
  bool union_set(int x, int y) {
    x = root(x); y = root(y);
    if(x!=y) {
      if(data[y] < data[x]) swap(x, y);
      data[x] += data[y]; data[y] = x;
    }
    return x != y;
  }
  bool find_set(int x, int y) { return root(x) == root(y); }
  int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
  int size(int x) { return -data[root(x)]; }
};
#pragma endregion


// ?????°
#pragma region CONST_VAL
#define PI (2*acos(0.0))
#define EPS (1e-9)
#define MOD (int)(1e9+7)
#pragma endregion

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 a, b;
    while(cin>>a>>b) {
        printf("%d %d", gcd(a,b), lcm(a,b));

    }
    return 0;
}

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

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

long long gcd(long long a, long long b);

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

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

C++: #include <stdio.h>

int main(void){
    long a,b,i=2;
    while(scanf("%ld %ld",&a,&b)!=EOF){
        i=a;
        while(1){
            if(a%i==0&&b%i==0) break;
            i--;
        }
        printf("%ld %ld\n",i,a*b/i);
    }
    return 0;
}

C++: #include <iostream>
 
using namespace std;
 
int main() {
 
    long long int ain[50],bin[50];
    long long int a,b,c,d,e,gcm,lcd;
    int loop=50;
    
    for(int i = 0;i<50;i++) {
    	ain[i]=0;
    	bin[i]=0;
        cin >> ain[i] >> bin[i];
        /*if (ain[i]==null) {
        	loop = i;
        	break;
        }*/
    }
    for (int i = 0;i <= loop;i++) {
    a = ain[i];
    b = bin[i];
    if (a==0&&b==0) break;
    if (a < b) {
        c  = a;
        a  = b;
        b = c;
        c=0;
    }
 
    c=a;
    d=b;
 
    for(;;) {
        if(d==0) {
            gcm = c;
            lcd = (a * b) / gcm;
            break;
        }
        e = c % d;
        c = d;
        d = e;
    }
 
    cout << gcm << " " << lcd << endl;
    }
 
    return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
int main()
{
    long long int n1,n2,gcd,lcm,c;
    while(scanf("%lld%lld",&n1,&n2)!=EOF)
    {

   c=__gcd(n1,n2);
    lcm=(n1*n2)/c;
        printf("%lld %lld\n",c,lcm);
        }
    return 0;
}

C++: #include <iostream>
#include <vector>
using namespace std;
int main() {
 int a,b,c,x,y;
 vector<int> lcm,gcm;
 while(cin >> a >> b) {
 if (a<b) swap(a,b); 
 x=a; y=b;
 while( a % b!=0) { c=b; b=a % b; a=c; }
 lcm.push_back(b); y=y/b; gcm.push_back(y*x);
 }
 for (c=0;c<lcm.size();c++) cout << lcm[c] << " " << gcm[c] << endl; 
 return 0;
}

C++: #include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>

#define f first
#define s second
#define mp make_pair

#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
#define EPS (1e-10)
using namespace std;

typedef unsigned int uint;
typedef long long ll;

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

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