Go: package main

import "fmt"

func main() {
	var gcdArr, lcmArr [50]int
	var count int
	for {
		var x, y int
		fmt.Scanf("%d %d", &x, &y)
		if count == 51 {
			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++: #include <stdio.h>
#include <iostream>
#include <math.h>

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

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

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

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

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


const int GCM(const int a,const int b){
	int x(a),y(b);
	while(x%=y){
		std::swap(x,y);
	}
	return y;
}

const int LCM(const int a,const int b){
	int x(a),y(b);
	while(x%=y){
		std::swap(x,y);
	}
	int tmp(a/y);
	tmp*=b;
	return tmp;
}


int main(int,char**){
	int a,b;
	while(std::cin >>a){
		std::cin >> b;
		std::cout << GCM(a,b) << ' ' << LCM(a,b)<<std::endl;
	}
	return 0;
}

C++: #include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<string>
#include<vector>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
const int INF = 0x3fffffff;

int x, y;

int gcd(int x, int y) { if(!y) return x; else return gcd(y, x%y); }

int main()
{
	while(scanf("%d%d",&x,&y) != EOF)
	{
		int ans = gcd(x, y);
		cout<<ans<<" "<<(ll)x*y/ans<<endl;
	}
	return 0;
}

C++: #include<iostream>
using namespace std;
int main(){
bool aaa;
int as,c;
float asd;
int a,b,gcd,lcm;
while(cin>>a>>b){
c=1;
gcd=1;
aaa=true;
while(aaa){
c++;
as=a/c;
asd=a/c;
if(as==asd){
as=b/c;
asd=b/c;
if(as==asd){
gcd*=c;
a/=c;
b/=c;
}
}
if(a==1||b==1){aaa=false;}
}
lcm=a*b/gcd;
cout<<gcd<<" "<<lcm<<endl;
}
}

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

using namespace std;

/*Assumption:a > b*/
int gcd(int a, int b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}

/*c is gcd.*/
int lcm(int a, int b, int c) {
  return (a / c) * b;
}

int main() {
  int a, b, c;
  while(cin >> a >> b) {
    swap(a, b);
    c = gcd(a, b);
    cout << c << ' ' << lcm(a, b, c) << endl;
  }
  return 0;
}

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

using namespace std;

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

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

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

typedef unsigned long int uint;

uint func1(uint a,uint b){
    while(a != b){
        if(a>b)a-=b;
        else b-=a;
    }
    return a;
}

uint func2(const uint a,const uint b){
    uint a2=a,b2=b;
    while(a2 != b2){
        if(a2>b2)b2+=b;
        else a2+=a;
    }
    return a2;
}

int main(){
    uint a,b;
    cin >> a >> b;

    cout << func1(a,b) << " " << func2(a,b);

    return 0;
}

C++: #include <iostream>
#include <cstdio> 
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <algorithm>
#include <complex>
using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;

#ifndef typeof
#define typeof __typeof__
#endif // typeof
 
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define tr(c, i) for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define rtr(c, i) for(typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define repby(i, a, b, step) for(typeof(b) i = (a); i < (b); i += (step))
#define repab(i, a, b) repby(i, (a), (b), 1)
#define rep(i, n) repab(i, 0, (n))
#define pb push_back
#define sz(c) int((c).size())

int gcd(int a, int b) {
  if (a < b)
    return gcd(b, a);

  int m = a % b;
  if (m == 0)
    return b;
  else
    return gcd(b, m);
}

int main(int argc, char **argv)
{
  int a, b;

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

  return 0;
}

C++: #include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)

#define int long long 
using namespace std;
signed main(){
 int a,b;
 while(cin >> a >> b){
  int g = __gcd(a,b);
  int l = a*b/g;
  cout << g << " " << l << endl;
 } 
 return 0;
}

C++: #include<iostream>
using namespace std;
long long int sub(long long int x,long long int y);
int sort(long long int *a,long long int *b);
int main(){
long long int a,b,c,x,y;
  cin>>a>>b;
  c=a*b;
  sort(&a,&b);
  while(1){
    if(a==b)break;
    x=sub(a,b);
    sort(&b,&x);
    a=b;
    b=x;
  }
  y=c/b;
  cout<<b<<" "<<y<<endl;
}
long long int sub(long long int x,long long int y){
  return x-y;
}
int sort(long long int *a,long long int *b){
  if(*a<*b){
    long long int temp =*a;
    *a=*b;
    *b=temp;
  }
}

C++: #include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
typedef long long int lnt;
typedef pair<lnt,lnt> P;
lnt a,b;
lnt euk(lnt x,lnt y){
	if(x<y) return euk(y,x);
	if(y==0) return x;
	return euk(y,x%y);
}

int main()
{
	while(scanf("%lld%lld",&a,&b)!=EOF){
		lnt x=euk(a,b);
		cout<<x<<' '<<a*b/x<<endl;
	}
}

C++: #define _CRT_SECURE_NO_WARNINGS

#include<fstream>
#include<iostream>
#include<string>
#include<iomanip>
#include<list>
#include<math.h>
#include<stack>
#include<queue>
#include<vector>

using namespace std;

int main(int argc, char **argv){
	int a, b;
	while (std::cin >> a >> b) {
		int tmp_a = a, tmp_b = b;
		while (a % b != 0) {
			int tmp = a % b;
			a = b;
			b = tmp;
		}
		cout << b << " " << (tmp_a / b) * (tmp_b / b) * b << endl;
	}
	return 0;
}

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

int getGCD(int a, int b)
{
  /* a??¨b????????§??¬?´???°???????????? */
  int larger = a;
  int smaller = b;
  
  if (larger < smaller) {
    std::swap(larger, smaller);
  }
  
  int sub = larger - smaller;
  
  int ret = larger;
  while (sub > 0) {
    ret = sub;
    larger = sub;
    if (larger < smaller) {
      std::swap(larger, smaller);
    }
    sub = larger - smaller;
  }
  
  return ret;
}

int getLCM(int a, int b)
{
  /* a??¨b???????°???¬?????°???????????? */
  return a / getGCD(a, b) * b;
}

int main(void)
{
  int a, b;
  
  while (std::cin >> a >> b) {
    std::cout << getGCD(a, b) << " " << getLCM(a, b) << std::endl;
  }
  
  return 0;
}

C++: #include<stdio.h>
#include<algorithm>
using namespace std;
int i;
/*int js(long long x,long long y)
{
    for(i=1; ;i++)
    {
        if(i%x==0&&i%y==0)
        {
            break;
        }
    }
    return i;
}*/
main()
{
    long long n,k,j,max,min,x,y,t,a,b;
    while(~scanf("%lld %lld",&x,&y))
    {
        a=x;
        b=y;
       // max=js(x,y);
        if(x>y)
            {
                t=x;
                x=y;
                y=t;
            }
        while(x!=0)
        {
            t=x;
            x=y%x;
            y=t;

        }
        min=y;
        max=a*b/min;
    printf("%lld %lld\n",min,max);
    }

}