Language: C

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text.RegularExpressions;

namespace AtCoder
{
    public class MainClass
    {
        public static void Main(string[] args)
        {
            var sw = new StreamWriter(Console.OpenStandardOutput(), Console.Out.Encoding);
            sw.AutoFlush = false;
            Console.SetOut(sw);

            if (args.Length > 0 && args[0] == "debug")
            {
                var inputs = new[] { @"
117
				", @"
123
                ", @"
777
				", @"

				", @"

				" };

                foreach (var str in inputs)
                {
                    var text = str.Trim();
                    if (text.Length == 0) continue;
                    var reader = new System.IO.StringReader(text);
                    Console.SetIn(reader);
                    Main2(args);
                    Console.WriteLine();
                    Console.WriteLine("----------------------------------");
                    Console.WriteLine();
                }
            }
            else
                Main2(args);

            Console.Out.Flush();
        }

        public static void Main2(string[] args)
        {
            checked
            {
                var N=Console.ReadLine();
                if(N.Contains("7"))
                    Console.WriteLine("Yes");
                else
                    Console.WriteLine("No");
            }
        }
    }

    public static class EnumerablePlus
    {
        ///<summary>出力文字列に変換。</summary>
        public static string MkString<T>(this IEnumerable<T> list)
        {
            return list.Aggregate(
                new System.Text.StringBuilder(),
                (a, b) => ((a.Length > 0) ? a.Append(' ') : a).Append(b)
                ).ToString();
        }

        ///<summary>添字付きfor。</summary>
        public static void ForEach2<T>(this IEnumerable<T> list, Action<T, long> a)
        {
            long i = 0;
            foreach (var item in list)
            {
                a(item, i);
            }
        }

        ///<summary>添字付きfor。</summary>
        public static void ForEach<T>(this IEnumerable<T> list, Action<T> a)
        {
            foreach (var item in list)
            {
                a(item);
            }
        }

        ///<summary>指定回数デリゲートを呼び出す。</summary>
        public static IEnumerable<T> Repeat<T>(long n, Func<T> f)
        {
            for (long i = 0; i < n; i++)
            {
                yield return f();
            }
        }

        public static T MinBy<T, U>(this IEnumerable<T> xs, Func<T, U> key) where U : IComparable<U>
        {
            return xs.Aggregate((a, b) => key(a).CompareTo(key(b)) <= 0 ? a : b);
        }

        public static T MaxBy<T, U>(this IEnumerable<T> xs, Func<T, U> key) where U : IComparable<U>
        {
            return xs.Aggregate((a, b) => key(a).CompareTo(key(b)) >= 0 ? a : b);
        }

        public static List<T> MaxBy2<T, U>(this IEnumerable<T> xs, Func<T, U> key) where U : IComparable<U>
        {
            return xs.Aggregate(
                new List<T>(),
                (list, b) =>
                {
                    if (list.Count == 0) { list.Add(b); return list; }

                    var aa = key(list[0]);
                    var bb = key(b);

                    if (aa.CompareTo(bb) < 0) list.Clear();

                    if (aa.CompareTo(bb) <= 0) { list.Add(b); return list; }

                    return list;
                });
        }

        public static List<T> Max2<T>(this IEnumerable<T> xs) where T : IComparable<T>
        {
            return xs.MaxBy2(o => o);
        }

        public static void Move<T>(this IList<T> list, int from, int to)
        {
            var item = list[from];

            for (var idx = from; idx > to; --idx)
            {
                list[idx] = list[idx - 1];
            }

            list[to] = item;
        }

        public static void Add2<T>(this IDictionary<T, int> xs, T key)
        {
            if (xs.ContainsKey(key))
                xs[key]++;
            else
                xs.Add(key, 1);
        }
    }

    public static class MathPlus
    {
        ///<summary>約数。順番は不定。</summary>
        public static List<long> Divisor(long n)
        {
            var list = Prime(n).
                GroupBy(id => id).
                Select(pair => new { prime = pair.Key, power = pair.Count() }).
                ToList();

            var result = list.Aggregate(new List<long>(), (left, pair) =>
            {
                var list2 = Enumerable.
                    Range(0, pair.power + 1).
                    Aggregate(new List<long>(), (res, l) =>
                    {
                        var next = res.Count > 0 ? res.Last() * pair.prime : 1L;
                        res.Add(next);
                        return res;
                    });

                if (left.Count == 0) return list2.ToList();

                return list2.
                    SelectMany(l => left.Select(m => l * m)).
                    ToList();
            });

            return result;
        }

        ///<summary>順列の数。</summary>
        public static long Permutation(long n, long r)
            => Factorial(n, r);

        ///<summary>組合せの数。</summary>
        public static long Combination(long n, long r)
        {
            if (r == 0) return 1;

            return Factorial(n, r) / Factorial(r);
        }

        ///<summary>階乗。カウントも指定可能。</summary>
        public static long Factorial(long a, long count = long.MaxValue)
        {
            long res = 1;

            for (long i = 0; a > 0 && i < count; i++)
            {
                checked { res *= a; }
                --a;
            }

            return res;
        }

        ///<summary>素因数分解。昇順。</summary>
        public static List<long> Prime(long a)
        {
            var res = new List<long>();

            var a2 = Math.Ceiling(Math.Sqrt(a));
            for (long b = 2; b <= a2; ++b)
            {
                while (a % b == 0)
                {
                    res.Add(b);
                    a = a / b;
                    a2 = Math.Ceiling(Math.Sqrt(a));
                }
            }

            if (a > 1) res.Add(a);
            return res;
        }

        ///<summary>最小公倍数。</summary>
        public static long Lcm(IEnumerable<long> list)
        {
            return list.Aggregate((a, b) => Lcm(a, b));
        }

        ///<summary>最小公倍数。</summary>
        public static long Lcm(long a, long b)
        {
            return checked(a * b) / Gcd(a, b);
        }

        ///<summary>最大公約数。</summary>
        public static long Gcd(IEnumerable<long> list)
        {
            return list.Aggregate((a, b) => Gcd(a, b));
        }

        ///<summary>最大公約数。</summary>
        public static long Gcd(long a, long b)
        {
            if (a < b)
                Gcd(b, a);

            while (b != 0)
            {
                var rem = a % b;
                a = b;
                b = rem;
            }

            return a;
        }

        ///<summary>切り上げ。</summary>
        public static long Ceiling(long a, long b) => (a + (b - 1)) / b;
    }
}


Compiler output:
main.c:1:1: error: unknown type name 'using'
    1 | using System;
      | ^~~~~
main.c:2:1: error: unknown type name 'using'
    2 | using System.Collections;
      | ^~~~~
main.c:2:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    2 | using System.Collections;
      |             ^
main.c:3:1: error: unknown type name 'using'
    3 | using System.Collections.Generic;
      | ^~~~~
main.c:3:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    3 | using System.Collections.Generic;
      |             ^
main.c:4:1: error: unknown type name 'using'
    4 | using System.Linq;
      | ^~~~~
main.c:4:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    4 | using System.Linq;
      |             ^
main.c:5:1: error: unknown type name 'using'
    5 | using System.IO;
      | ^~~~~
main.c:5:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    5 | using System.IO;
      |             ^
main.c:6:1: error: unknown type name 'using'
    6 | using System.Text.RegularExpressions;
      | ^~~~~
main.c:6:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    6 | using System.Text.RegularExpressions;
      |             ^
main.c:8:1: error: unknown type name 'namespace'
    8 | namespace AtCoder
      | ^~~~~~~~~
main.c:9:1: error: expected '=', ',', ';', 'asm' or '__attribute__' before '{' token
    9 | {
      | ^
main.c:20:38: error: stray '@' in program
   20 |                 var inputs = new[] { @"
      |                                      ^
main.c:20:39: warning: missing terminating " character
   20 |                 var inputs = new[] { @"
      |                                       ^
main.c:20:39: error: missing terminating " character
main.c:30:33: warning: missing terminating " character
   30 |                                 " };
      |                                 ^
main.c:30:33: error: missing terminating " character
   30 |                                 " };
      |                                 ^~~~