Language: C

use std::io::stdin;
use std::vec::Vec;

mod utils {
    use std::io::BufRead;
    use std::str::{self, FromStr};

    pub struct StdinReader<R: BufRead> {
        reader: R,
        buf: Vec<u8>,
    }

    impl<R: BufRead> StdinReader<R> {
        pub fn new(reader: R) -> StdinReader<R> {
            StdinReader {
                reader: reader,
                buf: Vec::new(),
            }
        }

        #[allow(unused)]
        #[inline]
        pub fn reads<T: FromStr>(&mut self) -> T {
            self.read_until(b' ')
        }

        #[allow(unused)]
        #[inline]
        pub fn readl<T: FromStr>(&mut self) -> T {
            self.read_until(b'\n')
        }

        #[allow(unused)]
        #[inline]
        pub fn read_vec<T: FromStr>(&mut self) -> Vec<T> {
            return self.read_until::<String>(b'\n').trim().split_whitespace().map(|c| c.parse().ok().unwrap()).collect();
        }

        #[inline]
        pub fn read_until<T: FromStr>(&mut self, delim: u8) -> T {
            loop {
                self.buf.clear();
                let len = self.reader
                    .read_until(delim, &mut self.buf)
                    .expect("failed reading bytes");
                match len {
                    0 => panic!("early eof"),
                    1 if self.buf[0] == delim => (),
                    _ => {
                        if self.buf[len - 1] == delim {
                            self.buf.truncate(len - 1);
                        }
                        break;
                    }
                }
            }

            let elem = unsafe { str::from_utf8_unchecked(&self.buf) };
            elem.parse().unwrap_or_else(|_| panic!(format!("failed parsing: {}", elem)))
         }
    }
}


fn main(){
    let stdin = stdin();
    let mut r = utils::StdinReader::new(stdin.lock());
    let n:u32 = r.readl();
    let s = n.to_string();
    let splitted_s:Vec<&str> = s.split("").collect();
    let mut res = "No";
    for i in splitted_s {
        if(i == "7"){
            res = "Yes";
            break;
        }
    }

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


Compiler output:
main.c:1:1: error: unknown type name 'use'
    1 | use std::io::stdin;
      | ^~~
main.c:1:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    1 | use std::io::stdin;
      |        ^~
main.c:2:1: error: unknown type name 'use'
    2 | use std::vec::Vec;
      | ^~~
main.c:2:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '::' token
    2 | use std::vec::Vec;
      |        ^~
main.c:4:1: error: unknown type name 'mod'
    4 | mod utils {
      | ^~~
main.c:4:11: error: expected '=', ',', ';', 'asm' or '__attribute__' before '{' token
    4 | mod utils {
      |           ^
main.c:21:10: error: invalid preprocessing directive #[
   21 |         #[allow(unused)]
      |          ^
main.c:22:10: error: invalid preprocessing directive #[
   22 |         #[inline]
      |          ^
main.c:27:10: error: invalid preprocessing directive #[
   27 |         #[allow(unused)]
      |          ^
main.c:28:10: error: invalid preprocessing directive #[
   28 |         #[inline]
      |          ^
main.c:33:10: error: invalid preprocessing directive #[
   33 |         #[allow(unused)]
      |          ^
main.c:34:10: error: invalid preprocessing directive #[
   34 |         #[inline]
      |          ^
main.c:39:10: error: invalid preprocessing directive #[
   39 |         #[inline]
      |          ^
main.c:65:1: error: unknown type name 'fn'
   65 | fn main(){
      | ^~
main.c: In function 'main':
main.c:66:5: error: unknown type name 'let'
   66 |     let stdin = stdin();
      |     ^~~
main.c:66:17: error: called object 'stdin' is not a function or function pointer
   66 |     let stdin = stdin();
      |                 ^~~~~
main.c:66:9: note: declared here
   66 |     let stdin = stdin();
      |         ^~~~~
main.c:67:5: error: unknown type name 'let'
   67 |     let mut r = utils::StdinReader::new(stdin.lock());
      |     ^~~
main.c:67:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'r'
   67 |     let mut r = utils::StdinReader::new(stdin.lock());
      |             ^
main.c:68:5: error: unknown type name 'let'
   68 |     let n:u32 = r.readl();
      |     ^~~
main.c:68:10: error: expected '=', ',', ';', 'asm' or '__attribute__' before ':' token
   68 |     let n:u32 = r.readl();
      |          ^
main.c:69:5: error: unknown type name 'let'
   69 |     let s = n.to_string();
      |     ^~~
main.c:69:13: error: 'n' undeclared (first use in this function)
   69 |     let s = n.to_string();
      |             ^
main.c:69:13: note: each undeclared identifier is reported only once for each function it appears in
main.c:70:5: error: unknown type name 'let'
   70 |     let splitted_s:Vec<&str> = s.split("").collect();
      |     ^~~
main.c:70:19: error: expected '=', ',', ';', 'asm' or '__attribute__' before ':' token
   70 |     let splitted_s:Vec<&str> = s.split("").collect();
      |                   ^
main.c:71:5: error: unknown type name 'let'
   71 |     let mut res = "No";
      |     ^~~
main.c:71:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'res'
   71 |     let mut res = "No";
      |             ^~~
main.c:72:9: error: expected '(' before 'i'
   72 |     for i in splitted_s {
      |         ^
      |         (
main.c:72:9: error: 'i' undeclared (first use in this function)