Language: C

// https://atcoder.jp/contests/abc163/tasks/abc163_b
//
#![allow(unused_imports)]
use std::io::*;
use std::io::Write;
use std::fmt::*;
use std::str::*;
use std::cmp::*;
use std::collections::*;

// Input macros.
// Original by tanakh: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

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

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

#[allow(unused_macros)]
macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

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

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

    ($iter:expr, switch) => {
        {
            let ty = read_value!($iter, i32);
            if ty == 1 {
                vec![ty, read_value!($iter, i32), read_value!($iter, i32)]
            } else if ty == 2 {
                vec![ty, read_value!($iter, i32)]
            } else {
                vec![ty, read_value!($iter, i32)]
            }
        }
    };

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

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

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_macros)]
macro_rules! read_line {
    ($t:tt) => {
        {
            let mut s = String::new();
            std::io::stdin().read_line(&mut s).unwrap();
            s.trim_right().parse::<$t>().unwrap()
        }
    }
}

#[allow(unused_macros)]
macro_rules! dvec {
    ($t:expr ; $len:expr) => {
        vec![$t; $len]
    };

    ($t:expr ; $len:expr, $($rest:expr),*) => {
        vec![dvec!($t; $($rest),*); $len]
    };
}

#[allow(unused_macros)]
macro_rules! ifv {
    ($t:expr, $a:expr, $b: expr) => {
        if $t { $a } else { $b }
    }
}

#[allow(unused_macros)]
macro_rules! fill {
    ($t:expr, $v:expr) => {
        for i in 0..$t.len() {
            $t[i] = $v;
        }
    };
}

#[allow(unused_macros)]
macro_rules! join {
    ($t:expr, $glue:expr) => {
        $t.into_iter().map(|w| w.to_string()).collect::<Vec<_>>().join($glue)
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

// ===

fn main() {
    input! {
        n: i32, m: usize,
        a: [i32; m]
    };

    let sum: i32 = a.iter().sum();
    println!("{}", ifv!(sum > n, -1, n - sum));
}


Compiler output:
main.c:3:2: error: invalid preprocessing directive #!
    3 | #![allow(unused_imports)]
      |  ^
main.c:4:1: error: unknown type name 'use'
    4 | use std::io::*;
      | ^~~
main.c:4:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    4 | use std::io::*;
      |        ^~
main.c:5:1: error: unknown type name 'use'
    5 | use std::io::Write;
      | ^~~
main.c:5:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    5 | use std::io::Write;
      |        ^~
main.c:6:1: error: unknown type name 'use'
    6 | use std::fmt::*;
      | ^~~
main.c:6:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    6 | use std::fmt::*;
      |        ^~
main.c:7:1: error: unknown type name 'use'
    7 | use std::str::*;
      | ^~~
main.c:7:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    7 | use std::str::*;
      |        ^~
main.c:8:1: error: unknown type name 'use'
    8 | use std::cmp::*;
      | ^~~
main.c:8:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    8 | use std::cmp::*;
      |        ^~
main.c:9:1: error: unknown type name 'use'
    9 | use std::collections::*;
      | ^~~
main.c:9:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    9 | use std::collections::*;
      |        ^~
main.c:13:2: error: invalid preprocessing directive #[
   13 | #[allow(unused_macros)]
      |  ^
main.c:14:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
   14 | macro_rules! input {
      |            ^
main.c:31:2: error: invalid preprocessing directive #[
   31 | #[allow(unused_macros)]
      |  ^
main.c:32:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
   32 | macro_rules! input_inner {
      |            ^
main.c:47:2: error: invalid preprocessing directive #[
   47 | #[allow(unused_macros)]
      |  ^
main.c:48:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
   48 | macro_rules! read_value {
      |            ^
main.c:54:10: error: too many decimal points in number
   54 |         (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
      |          ^~~~~~~
main.c:60:14: error: too many decimal points in number
   60 |             (0..len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
      |              ^~~~~~
main.c:90:2: error: invalid preprocessing directive #[
   90 | #[allow(unused_macros)]
      |  ^
main.c:91:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
   91 | macro_rules! read_line {
      |            ^
main.c:101:2: error: invalid preprocessing directive #[
  101 | #[allow(unused_macros)]
      |  ^
main.c:102:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
  102 | macro_rules! dvec {
      |            ^
main.c:112:2: error: invalid preprocessing directive #[
  112 | #[allow(unused_macros)]
      |  ^
main.c:113:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
  113 | macro_rules! ifv {
      |            ^
main.c:119:2: error: invalid preprocessing directive #[
  119 | #[allow(unused_macros)]
      |  ^
main.c:120:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
  120 | macro_rules! fill {
      |            ^
main.c:122:18: error: too many decimal points in number
  122 |         for i in 0..$t.len() {
      |                  ^~~~~~~~~
main.c:128:2: error: invalid preprocessing directive #[
  128 | #[allow(unused_macros)]
      |  ^
main.c:129:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
  129 | macro_rules! join {
      |            ^
main.c:135:2: error: invalid preprocessing directive #[
  135 | #[allow(unused_macros)]
      |  ^
main.c:136:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before '!' token
  136 | macro_rules! debug {
      |            ^
main.c:144:1: error: unknown type name 'fn'
  144 | fn main() {
      | ^~
main.c: In function 'main':
main.c:145:5: error: 'input' undeclared (first use in this function); did you mean 'int'?
  145 |     input! {
      |     ^~~~~
      |     int
main.c:145:5: note: each undeclared identifier is reported only once for each function it appears in
main.c:145:10: error: expected ';' before '!' token
  145 |     input! {
      |          ^
      |          ;
main.c:150:5: error: unknown type name 'let'
  150 |     let sum: i32 = a.iter().sum();
      |     ^~~
main.c:150:12: error: expected '=', ',', ';', 'asm' or '__attribute__' before ':' token
  150 |     let sum: i32 = a.iter().sum();
      |            ^
main.c:151:5: error: 'println' undeclared (first use in this function)
  151 |     println!("{}", ifv!(sum > n, -1, n - sum));
      |     ^~~~~~~
main.c:151:12: error: expected ';' before '!' token
  151 |     println!("{}", ifv!(sum > n, -1, n - sum));
      |            ^
      |            ;