简单 Rust 实现辗转相除法，输入输出库参照站长之前的一份板子

use utils::*;
mod utils {
    #[allow(unused)]
    pub use std::convert::TryInto;
    pub use std::io::{BufRead, Write};
    use std::{
        cell::UnsafeCell,
        io::{BufReader, BufWriter, StdinLock, StdoutLock, stdin, stdout},
    };

    #[allow(unused)]
    pub const T_CASE: bool = false;

    #[inline(always)]
    pub fn runner<const E: bool>(solve: fn(i32) -> ()) {
        #[allow(unused_must_use)]
        unsafe {
            _STDIN
                .inner
                .get()
                .as_mut()
                .unwrap()
                .insert(BufReader::new(stdin().lock()));
            _STDOUT
                .inner
                .get()
                .as_mut()
                .unwrap()
                .insert(BufWriter::new(stdout().lock()));
        }
        if E {
            (1..=crate::readln!(i32)).for_each(solve);
        } else {
            solve(1);
        }
        crate::flush!();
    }

    #[macro_export]
    macro_rules! solve {
        ($solve:expr) => {
            // 这里的函数名必须是 main，IDE 才会出运行按钮
            #[allow(unused_unsafe)]
            fn main() {
                runner::<T_CASE>($solve);
            }
        };
    }

    pub(super) struct FastCell<T> {
        pub(super) inner: UnsafeCell<Option<T>>,
    }
    unsafe impl<T> Sync for FastCell<T> {}

    pub static _STDIN: FastCell<BufReader<StdinLock>> = FastCell {
        inner: UnsafeCell::new(None),
    };

    #[macro_export]
    macro_rules! has_next {
        () => {
            unsafe {
                match _STDIN
                    .inner
                    .get()
                    .as_mut()
                    .unwrap()
                    .as_mut()
                    .unwrap()
                    .fill_buf()
                {
                    Ok(n) => !n.is_empty(),
                    Err(_) => false,
                }
            }
        };
    }

    #[macro_export]
    macro_rules! readln {
        () => {
            unsafe {
                let mut line = String::new();
                _ = _STDIN
                    .inner
                    .get()
                    .as_mut()
                    .unwrap()
                    .as_mut()
                    .unwrap()
                    .read_line(&mut line)
                    .unwrap();
                line
            }
        };
        ($T: ty) => {
            unsafe {
                let mut line = String::new();
                _ = _STDIN
                    .inner
                    .get()
                    .as_mut()
                    .unwrap()
                    .as_mut()
                    .unwrap()
                    .read_line(&mut line)
                    .unwrap();
                line.trim_ascii().parse::<$T>().unwrap()
            }
        };
    }

    #[macro_export]
    macro_rules! mapln {
        ($T: ty) => {
            unsafe {
                let mut line = String::new();
                _ = _STDIN
                    .inner
                    .get()
                    .as_mut()
                    .unwrap()
                    .as_mut()
                    .unwrap()
                    .read_line(&mut line)
                    .unwrap();
                line.split_ascii_whitespace()
                    .map(|s| s.parse().ok().unwrap())
                    .collect::<Vec<$T>>()
            }
        };
    }

    #[macro_export]
    macro_rules! unpack {
        ($e: expr) => {
            ($e).try_into().unwrap()
        };
    }

    pub static _STDOUT: FastCell<BufWriter<StdoutLock>> = FastCell {
        inner: UnsafeCell::new(None),
    };

    #[macro_export]
    macro_rules! print {
        ($($arg:tt)*) => {
            unsafe { write!(_STDOUT.inner
            .get()
            .as_mut()
            .unwrap().as_mut().unwrap(), $($arg)*) }.unwrap()
        }
    }

    #[macro_export]
    macro_rules! println {
        () => {
            unsafe { writeln!(_STDOUT.inner
            .get()
            .as_mut()
            .unwrap().as_mut().unwrap()) }.unwrap()
        };
        ($($arg:tt)*) => {
            unsafe { writeln!(_STDOUT.inner
            .get()
            .as_mut()
            .unwrap().as_mut().unwrap(), $($arg)*) }.unwrap()
        }
    }

    #[macro_export]
    macro_rules! flush {
        () => {
            unsafe {
                _STDOUT
                    .inner
                    .get()
                    .as_mut()
                    .unwrap()
                    .as_mut()
                    .unwrap()
                    .flush()
                    .unwrap()
            }
        };
    }
}
solve!(|_| {
    let mut s = mapln!(i64);
    s.sort();
    let __lcm = s[0] * s[1];
    let (mut a, mut b) = (s[0], s[1]);
    let mut ans = b;
    while a != 0 {
        let mut c = b % a;
        b = a;
        a = c;
    }
    println!("{} {}", b, __lcm / b);
});