Language: C

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
fn main() {
    input!(
    k: u64
    );
    let mut ans = 0;
    for a in 1..=k{
        for b in 1..=k{
            let t = gcd(a,b);
            for c in 1..=k{
                ans += gcd(t, c);
            }

        }
    }
    println!("{}", ans);
}

fn gcd(a: u64, b: u64) -> u64 {
    if b == 0 {
        a
    } else {
        gcd(b, a % b)
    }
}


Compiler output:
main.c:1:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
    1 | macro_rules! input {
      |            ^
main.c:22:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
   22 | macro_rules! input_inner {
      |            ^
main.c:32:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
   32 | macro_rules! read_value {
      |            ^
main.c:38:10: error: too many decimal points in number
   38 |         (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
      |          ^~~~~~~
main.c:53:1: error: unknown type name 'fn'
   53 | fn main() {
      | ^~
main.c: In function 'main':
main.c:54:5: error: 'input' undeclared (first use in this function); did you mean 'int'?
   54 |     input!(
      |     ^~~~~
      |     int
main.c:54:5: note: each undeclared identifier is reported only once for each function it appears in
main.c:54:10: error: expected ';' before '!' token
   54 |     input!(
      |          ^
      |          ;
main.c:57:5: error: unknown type name 'let'
   57 |     let mut ans = 0;
      |     ^~~
main.c:57:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'ans'
   57 |     let mut ans = 0;
      |             ^~~
main.c:58:9: error: expected '(' before 'a'
   58 |     for a in 1..=k{
      |         ^
      |         (
main.c:58:9: error: 'a' undeclared (first use in this function)
main.c:58:14: error: too many decimal points in number
   58 |     for a in 1..=k{
      |              ^~~
main.c:59:18: error: too many decimal points in number
   59 |         for b in 1..=k{
      |                  ^~~
main.c:61:22: error: too many decimal points in number
   61 |             for c in 1..=k{
      |                      ^~~
main.c: At top level:
main.c:70:1: error: unknown type name 'fn'
   70 | fn gcd(a: u64, b: u64) -> u64 {
      | ^~
main.c:70:9: error: expected ')' before ':' token
   70 | fn gcd(a: u64, b: u64) -> u64 {
      |         ^
      |         )