Problem:
Score : 300 points

Problem Statement

Takahashi is organizing a party.

At the party, each guest will receive one or more snack pieces.

Takahashi predicts that the number of guests at this party will be A or B.

Find the minimum number of pieces that can be evenly distributed to the guests in both of the cases predicted.

We assume that a piece cannot be divided and distributed to multiple guests.

Constraints

1 \leq A, B \leq 10^5

A \neq B

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the minimum number of pieces that can be evenly distributed to the guests in both of the cases with A guests and B guests.

Sample Input 1

2 3

Sample Output 1

6

When we have six snack pieces, each guest can take three pieces if we have two guests, and each guest can take two if we have three guests.

Sample Input 2

123 456

Sample Output 2

18696

Sample Input 3

100000 99999

Sample Output 3

9999900000

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::*;
use std::str::FromStr;
   
fn read<T: FromStr>() -> T {
	let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

// greatest common divisior
fn gcd(n: i64, m: i64) -> i64 {
	let mut x = 0;
	let mut y = 0;
	println!("n: {}, m: {}", n, m);
		
	if n >= m {
		x = n;
		y = m;
	} else {
		x = m;
		y = n;
	}

	// x > y
	let mut r = x % y;
	if r == 0 {
		return y;
	} else {
		return gcd(y, r);
	}
}
     
fn main() {
	let a: i64 = read();
    let b: i64 = read();

	let gcd_input= gcd(a, b);
	println!("{}", gcd_input);

	let lcm = (a * b) / gcd_input;
	println!("{}", lcm);
}