Language: C++

fn main(){
    let mut hs: Vec<i32> = vec![];
    for _i in 0..10{
        let n=readln();
        hs.push(n);
    }
    hs.sort();
    for i in (7..10).rev(){
        println!("{}",hs[i]);
    }
}
    

// --- 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..10{
      |               ^~~~~
a.cc:8:15: error: too many decimal points in number
    8 |     for i in (7..10).rev(){
      |               ^~~~~
a.cc:15:2: error: invalid preprocessing directive #[
   15 | #[allow(unused_imports)]
      |  ^
a.cc:17:2: error: invalid preprocessing directive #[
   17 | #[allow(unused_imports)]
      |  ^
a.cc:29:14: error: too many decimal points in number
   29 |     for _ in 0..n {
      |              ^~~~
a.cc:1:1: error: 'fn' does not name a type
    1 | fn main(){
      | ^~
a.cc:16:1: error: 'use' does not name a type
   16 | use std::cmp::{max, min};
      | ^~~
a.cc:19:1: error: 'pub' does not name a type
   19 | pub trait FromLn {
      | ^~~
a.cc:22:1: error: 'pub' does not name a type
   22 | pub fn readln<T: FromLn>() -> T {
      | ^~~
a.cc:27:1: error: 'pub' does not name a type
   27 | pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
      | ^~~
a.cc:34:1: error: 'macro_rules' does not name a type
   34 | macro_rules! fromln_primitives {
      | ^~~~~~~~~~~
a.cc:43:1: error: 'fromln_primitives' does not name a type
   43 | fromln_primitives!(
      | ^~~~~~~~~~~~~~~~~
a.cc:59:1: error: 'impl' does not name a type
   59 | impl<T> FromLn for Vec<T>
      | ^~~~
a.cc:67:1: error: 'impl' does not name a type
   67 | impl FromLn for Vec<char> {
      | ^~~~
a.cc:72:1: error: 'macro_rules' does not name a type
   72 | macro_rules! fromln_tuple {
      | ^~~~~~~~~~~
a.cc:84:1: error: 'fromln_tuple' does not name a type
   84 | fromln_tuple!(A, B);
      | ^~~~~~~~~~~~
a.cc:85:1: error: 'fromln_tuple' does not name a type
   85 | fromln_tuple!(A, B, C);
      | ^~~~~~~~~~~~
a.cc:86:1: error: 'fromln_tuple' does not name a type
   86 | fromln_tuple!(A, B, C, D);
      | ^~~~~~~~~~~~
a.cc:87:1: error: 'fromln_tuple' does not name a type
   87 | fromln_tuple!(A, B, C, D, E);
      | ^~~~~~~~~~~~
a.cc:88:1: error: 'fromln_tuple' does not name a type
   88 | fromln_tuple!(A, B, C, D, E, F);
      | ^~~~~~~~~~~~