Language: C++

fn main(){
    let n=readln();
    for _i in 0..n{
        let mut v:Vec<i64> = readln();
        v.sort();
        if v[0]*v[0] + v[1]*v[1]==v[2]*v[2] {
            println!("YES");
        }
        else{
            println!("NO");
        }
    }

}
    

// --- template ---
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
 
pub trait FromLn {
    fn fromln(s: &str) -> Self;
}
pub fn readln<T: FromLn>() -> T {
    let mut buf = String::new();
    let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
    T::fromln(buf.trim())
}
pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
    let mut vs = vec![];
    for _ in 0..n {
        vs.push(readln());
    }
    vs
}
macro_rules! fromln_primitives {
    ($($t:ty),*) => { $(
        impl FromLn for $t {
            fn fromln(s: &str) -> $t {
                s.parse().unwrap()
            }
        }
    )* }
}
fromln_primitives!(
    String,
    bool,
    f32,
    f64,
    isize,
    i8,
    i16,
    i32,
    i64,
    usize,
    u8,
    u16,
    u32,
    u64
);
impl<T> FromLn for Vec<T>
where
    T: FromLn,
{
    fn fromln(s: &str) -> Vec<T> {
        s.split_whitespace().map(T::fromln).collect()
    }
}
impl FromLn for Vec<char> {
    fn fromln(s: &str) -> Vec<char> {
        s.chars().collect()
    }
}
macro_rules! fromln_tuple {
    ($($t:ident),*) => {
        impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {
            fn fromln(s: &str) -> ($($t),*) {
                let mut it = s.split_whitespace();
                let t = ($($t::fromln(it.next().unwrap())),*);
                assert_eq!(it.next(), None);
                t
            }
        }
    }
}
fromln_tuple!(A, B);
fromln_tuple!(A, B, C);
fromln_tuple!(A, B, C, D);
fromln_tuple!(A, B, C, D, E);
fromln_tuple!(A, B, C, D, E, F);



Compiler output:
a.cc:3:15: error: too many decimal points in number
    3 |     for _i in 0..n{
      |               ^~~~
a.cc:18:2: error: invalid preprocessing directive #[
   18 | #[allow(unused_imports)]
      |  ^
a.cc:20:2: error: invalid preprocessing directive #[
   20 | #[allow(unused_imports)]
      |  ^
a.cc:32:14: error: too many decimal points in number
   32 |     for _ in 0..n {
      |              ^~~~
a.cc:1:1: error: 'fn' does not name a type
    1 | fn main(){
      | ^~
a.cc:19:1: error: 'use' does not name a type
   19 | use std::cmp::{max, min};
      | ^~~
a.cc:22:1: error: 'pub' does not name a type
   22 | pub trait FromLn {
      | ^~~
a.cc:25:1: error: 'pub' does not name a type
   25 | pub fn readln<T: FromLn>() -> T {
      | ^~~
a.cc:30:1: error: 'pub' does not name a type
   30 | pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
      | ^~~
a.cc:37:1: error: 'macro_rules' does not name a type
   37 | macro_rules! fromln_primitives {
      | ^~~~~~~~~~~
a.cc:46:1: error: 'fromln_primitives' does not name a type
   46 | fromln_primitives!(
      | ^~~~~~~~~~~~~~~~~
a.cc:62:1: error: 'impl' does not name a type
   62 | impl<T> FromLn for Vec<T>
      | ^~~~
a.cc:70:1: error: 'impl' does not name a type
   70 | impl FromLn for Vec<char> {
      | ^~~~
a.cc:75:1: error: 'macro_rules' does not name a type
   75 | macro_rules! fromln_tuple {
      | ^~~~~~~~~~~
a.cc:87:1: error: 'fromln_tuple' does not name a type
   87 | fromln_tuple!(A, B);
      | ^~~~~~~~~~~~
a.cc:88:1: error: 'fromln_tuple' does not name a type
   88 | fromln_tuple!(A, B, C);
      | ^~~~~~~~~~~~
a.cc:89:1: error: 'fromln_tuple' does not name a type
   89 | fromln_tuple!(A, B, C, D);
      | ^~~~~~~~~~~~
a.cc:90:1: error: 'fromln_tuple' does not name a type
   90 | fromln_tuple!(A, B, C, D, E);
      | ^~~~~~~~~~~~
a.cc:91:1: error: 'fromln_tuple' does not name a type
   91 | fromln_tuple!(A, B, C, D, E, F);
      | ^~~~~~~~~~~~