Language: C

-- {-# LANGUAGE BangPatterns #-}
-- {-# LANGUAGE ScopedTypeVariables #-}
-- {-# LANGUAGE FlexibleContexts #-}
-- {-# LANGUAGE ViewPatterns #-}
-- {-# LANGUAGE OverloadedStrings #-}

import qualified Data.Vector as V
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.Vector.Algorithms.Merge as VAM
import qualified Data.Heap as HP
import qualified Data.ByteString.Char8 as BC
import qualified Data.Map as MP
import qualified Data.Set as ST
import qualified Data.Sequence as SQ
import Data.Array
import Data.Array.Unboxed
import Data.Array.ST
import Data.Array.IO
import Data.Maybe
import Data.Ratio
import Data.Char
import Data.Bits
import Data.List
import Data.Tuple
import Data.Functor
import Data.IORef
import Data.STRef
import Control.Applicative
import Control.Monad
import Control.Monad.ST
import Debug.Trace

--------------------------------------------------------------------------
main = do
   xs <- map digitToInt <$> str :: IO [Int]
   putStrLn $ 
        if elem 7 xs
            then "Yes"
            else "No"

--------------------------------------------------------------------------
    
-- Input Util
int :: IO Int
int = readLn 

double :: IO Double
double = readLn 

str :: IO String
str = getLine

strBC :: IO BC.ByteString
strBC = BC.getLine

sLineToIntL :: IO [Int]
sLineToIntL = getLine >>= return . map read . words

sLineToDoubleL :: IO [Double]
sLineToDoubleL = getLine >>= return . map read . words

sLineToIntV :: Int -> IO (VU.Vector Int)
sLineToIntV n = BC.getLine >>= return . VU.unfoldrN n (BC.readInt . BC.dropWhile isSpace)

sLineToDoubleV :: Int -> IO (VU.Vector Double)
sLineToDoubleV n = BC.getLine >>= return . VU.fromList . map (read . BC.unpack) . BC.words

mLinesToIntL :: Int -> IO [Int]
mLinesToIntL n = replicateM n readLn

mLinesToDoubleL :: Int -> IO [Double]
mLinesToDoubleL n = replicateM n readLn

mLinesToIntV :: Int -> IO (VU.Vector Int)
mLinesToIntV n = VU.replicateM n readLn

mLinesToDoubleV :: Int -> IO (VU.Vector Double)
mLinesToDoubleV n = VU.replicateM n (BC.getLine >>= return . read . BC.unpack)

mLinesToTupleL :: Int -> IO [(Int, Int)]
mLinesToTupleL n = replicateM n (getLine >>= return . (\[a,b] -> (a,b)) . map read . words)

mLinesToTupleV :: Int -> IO (VU.Vector (Int, Int))
mLinesToTupleV n = VU.replicateM n $ do
    bs <- strBC
    let
        Just (a, bs') = BC.readInt $ BC.dropWhile isSpace bs
        Just (b, _) = BC.readInt $ BC.dropWhile isSpace bs'
    return (a,b)
    
mLinesToTripleV :: Int -> IO (VU.Vector (Int, Int, Int))
mLinesToTripleV n = VU.replicateM n $ do
    bs <- strBC
    let
        Just (a, bs') = BC.readInt $ BC.dropWhile isSpace bs
        Just (b, bs'') = BC.readInt $ BC.dropWhile isSpace bs'
        Just (c, _) = BC.readInt $ BC.dropWhile isSpace bs''
    return (a,b,c)

-- others
strToChr :: String -> Char
strToChr [x] = x

chrToStr :: Char -> String
chrToStr x = [x]

m1 :: Int -> Int
m1 x = subtract 1 x

toDouble :: Int -> Double
toDouble x = fromIntegral x

toInt :: Double -> Int
toInt x = floor x

Compiler output:
main.c:1:1: error: expected identifier or '(' before '--' token
    1 | -- {-# LANGUAGE BangPatterns #-}
      | ^~
main.c:1:6: error: stray '#' in program
    1 | -- {-# LANGUAGE BangPatterns #-}
      |      ^
main.c:1:30: error: stray '#' in program
    1 | -- {-# LANGUAGE BangPatterns #-}
      |                              ^
main.c:2:1: error: expected identifier or '(' before '--' token
    2 | -- {-# LANGUAGE ScopedTypeVariables #-}
      | ^~
main.c:2:6: error: stray '#' in program
    2 | -- {-# LANGUAGE ScopedTypeVariables #-}
      |      ^
main.c:2:37: error: stray '#' in program
    2 | -- {-# LANGUAGE ScopedTypeVariables #-}
      |                                     ^
main.c:3:1: error: expected identifier or '(' before '--' token
    3 | -- {-# LANGUAGE FlexibleContexts #-}
      | ^~
main.c:3:6: error: stray '#' in program
    3 | -- {-# LANGUAGE FlexibleContexts #-}
      |      ^
main.c:3:34: error: stray '#' in program
    3 | -- {-# LANGUAGE FlexibleContexts #-}
      |                                  ^
main.c:4:1: error: expected identifier or '(' before '--' token
    4 | -- {-# LANGUAGE ViewPatterns #-}
      | ^~
main.c:4:6: error: stray '#' in program
    4 | -- {-# LANGUAGE ViewPatterns #-}
      |      ^
main.c:4:30: error: stray '#' in program
    4 | -- {-# LANGUAGE ViewPatterns #-}
      |                              ^
main.c:5:1: error: expected identifier or '(' before '--' token
    5 | -- {-# LANGUAGE OverloadedStrings #-}
      | ^~
main.c:5:6: error: stray '#' in program
    5 | -- {-# LANGUAGE OverloadedStrings #-}
      |      ^
main.c:5:35: error: stray '#' in program
    5 | -- {-# LANGUAGE OverloadedStrings #-}
      |                                   ^
main.c:7:1: error: unknown type name 'import'
    7 | import qualified Data.Vector as V
      | ^~~~~~
main.c:7:18: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'Data'
    7 | import qualified Data.Vector as V
      |                  ^~~~
main.c:82:56: error: stray '\' in program
   82 | mLinesToTupleL n = replicateM n (getLine >>= return . (\[a,b] -> (a,b)) . map read . words)
      |                                                        ^
main.c:88:20: warning: missing terminating ' character
   88 |         Just (a, bs') = BC.readInt $ BC.dropWhile isSpace bs
      |                    ^
main.c:88:20: error: missing terminating ' character
   88 |         Just (a, bs') = BC.readInt $ BC.dropWhile isSpace bs
      |                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.c:89:59: warning: missing terminating ' character
   89 |         Just (b, _) = BC.readInt $ BC.dropWhile isSpace bs'
      |                                                           ^
main.c:89:59: error: missing terminating ' character
main.c:96:20: warning: missing terminating ' character
   96 |         Just (a, bs') = BC.readInt $ BC.dropWhile isSpace bs
      |                    ^
main.c:96:20: error: missing terminating ' character
   96 |         Just (a, bs') = BC.readInt $ BC.dropWhile isSpace bs
      |                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.c:97:20: error: empty character constant
   97 |         Just (b, bs'') = BC.readInt $ BC.dropWhile isSpace bs'
      |                    ^~
main.c:97:62: warning: missing terminating ' character
   97 |         Just (b, bs'') = BC.readInt $ BC.dropWhile isSpace bs'
      |                                                              ^
main.c:97:62: error: missing terminating ' character
main.c:98:59: error: empty character constant
   98 |         Just (c, _) = BC.readInt $ BC.dropWhile isSpace bs''
      |                                                           ^~