Language: C++

use std::io;
use std::str::FromStr;
use std::str::Chars;
use std::i32;
use std::u8;
use std::f64;
use std::ascii::AsciiExt;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::collections::VecDeque;
use std::io::prelude::*;
use std::time::Duration;
use std::cmp;

macro_rules! println_stderr(
    ($($arg:tt)*) => { {
        let r = writeln!(&mut ::std::io::stderr(), $($arg)*);
        r.expect("failed printing to stderr");
    } }
);

macro_rules! print_stderr(
    ($($arg:tt)*) => { {
        let r = write!(&mut ::std::io::stderr(), $($arg)*);
        r.expect("failed printing to stderr");
    } }
);

fn main() {
    let v = next_ints();
    if v[0] <= 0 && v[1] >= 0 {
        println!("Zero");
    }
    else if v[0] > 0 && v[1] > 0 {
        println!("Positive");
    }
    else if v[0] < 0 && v[1] < 0 {
        println!("{}",match v[1] - v[0] {
            n if n % 2 == 0 => "Positive",
            _ => "Negative",
        })
    }
}

#[allow(dead_code)]
fn next_string() -> String {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    input
}

#[allow(dead_code)]
fn next_strings() -> Vec<String> {
    let input = next_string();
    input.split_whitespace().map(|x| x.parse().unwrap()).collect()
}

#[allow(dead_code)]
fn next_int() -> i64 {
    let input = next_string();
    i64::from_str(input.trim()).unwrap()
}

#[allow(dead_code)]
fn next_ints() -> Vec<i64> {
    let input = next_string();
    input.split_whitespace().map(|x| x.parse().unwrap()).collect()
}


Compiler output:
a.cc:47:2: error: invalid preprocessing directive #[
   47 | #[allow(dead_code)]
      |  ^
a.cc:54:2: error: invalid preprocessing directive #[
   54 | #[allow(dead_code)]
      |  ^
a.cc:60:2: error: invalid preprocessing directive #[
   60 | #[allow(dead_code)]
      |  ^
a.cc:66:2: error: invalid preprocessing directive #[
   66 | #[allow(dead_code)]
      |  ^
a.cc:1:1: error: 'use' does not name a type
    1 | use std::io;
      | ^~~
a.cc:2:1: error: 'use' does not name a type
    2 | use std::str::FromStr;
      | ^~~
a.cc:3:1: error: 'use' does not name a type
    3 | use std::str::Chars;
      | ^~~
a.cc:4:1: error: 'use' does not name a type
    4 | use std::i32;
      | ^~~
a.cc:5:1: error: 'use' does not name a type
    5 | use std::u8;
      | ^~~
a.cc:6:1: error: 'use' does not name a type
    6 | use std::f64;
      | ^~~
a.cc:7:1: error: 'use' does not name a type
    7 | use std::ascii::AsciiExt;
      | ^~~
a.cc:8:1: error: 'use' does not name a type
    8 | use std::collections::HashMap;
      | ^~~
a.cc:9:1: error: 'use' does not name a type
    9 | use std::collections::HashSet;
      | ^~~
a.cc:10:1: error: 'use' does not name a type
   10 | use std::collections::BTreeMap;
      | ^~~
a.cc:11:1: error: 'use' does not name a type
   11 | use std::collections::BTreeSet;
      | ^~~
a.cc:12:1: error: 'use' does not name a type
   12 | use std::collections::VecDeque;
      | ^~~
a.cc:13:1: error: 'use' does not name a type
   13 | use std::io::prelude::*;
      | ^~~
a.cc:14:1: error: 'use' does not name a type
   14 | use std::time::Duration;
      | ^~~
a.cc:15:1: error: 'use' does not name a type
   15 | use std::cmp;
      | ^~~
a.cc:17:1: error: 'macro_rules' does not name a type
   17 | macro_rules! println_stderr(
      | ^~~~~~~~~~~
a.cc:22:1: error: expected unqualified-id before ')' token
   22 | );
      | ^
a.cc:24:1: error: 'macro_rules' does not name a type
   24 | macro_rules! print_stderr(
      | ^~~~~~~~~~~
a.cc:29:1: error: expected unqualified-id before ')' token
   29 | );
      | ^
a.cc:31:1: error: 'fn' does not name a type
   31 | fn main() {
      | ^~
a.cc:48:1: error: 'fn' does not name a type
   48 | fn next_string() -> String {
      | ^~
a.cc:55:1: error: 'fn' does not name a type
   55 | fn next_strings() -> Vec<String> {
      | ^~
a.cc:61:1: error: 'fn' does not name a type
   61 | fn next_int() -> i64 {
      | ^~
a.cc:67:1: error: 'fn' does not name a type
   67 | fn next_ints() -> Vec<i64> {
      | ^~