Problem:
Score : 100 points

Problem Statement

You are given three integers A, B and C.
Determine whether C is not less than A and not greater than B.

Constraints

-100≤A,B,C≤100

A, B and C are all integers.

Input

Input is given from Standard Input in the following format:

A B C

Output

If the condition is satisfied, print Yes; otherwise, print No.

Sample Input 1

1 3 2

Sample Output 1

Yes

C=2 is not less than A=1 and not greater than B=3, and thus the output should be Yes.

Sample Input 2

6 5 4

Sample Output 2

No

C=4 is less than A=6, and thus the output should be No.

Sample Input 3

2 2 2

Sample Output 3

Yes

Solution in C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;

namespace AtCorderPractice
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            var result = "";
            var _ = LnInts();
            var N = _[0]; var M = _[1];
            var nodes = new Node[N];

            for (int i = 0; i < M; i++)
            {
                var __ = LnInts();
                var startPoint = __[0] - 1;
                var endPoint = __[1] - 1;
                long cost = __[2];
                if (nodes[startPoint] == null) nodes[startPoint] = new Node();
                nodes[startPoint].nodeIndexes.Add(endPoint);
                nodes[startPoint].routeCost.Add(cost);
                nodes[startPoint].thisTotalCost = startPoint == 0 ? 0 : long.MinValue;
            }
            for (int i = 0; i < N; i++)
            {
                if (nodes[i] == null)
                {
                    nodes[i] = new Node();
                    nodes[i].thisTotalCost = i == 0 ? 0 : long.MinValue;
                }
            }
            bool isUpdated = true;
            int loopCount = 0;
            while (isUpdated)
            {
                isUpdated = false;
                for (int i = 0; i < N; i++)
                {
                    for (int n = 0; n < nodes[i].nodeIndexes.Count; n++)
                    {
                        if (nodes[i].thisTotalCost + nodes[i].routeCost[n] > nodes[nodes[i].nodeIndexes[n]].thisTotalCost)
                        {
                            nodes[nodes[i].nodeIndexes[n]].thisTotalCost = nodes[i].thisTotalCost + nodes[i].routeCost[n];
                            isUpdated = true;
                        }
                    }
                }
                loopCount++;
                if (isUpdated) { if (loopCount > N + 1) { result = "inf"; break; } }
            }
            if (result.Equals(""))
            {
                var score = nodes[N - 1].thisTotalCost;
                result = score.ToString();
            }
            Console.WriteLine(result);
        }

        public class Node
        {
            public List<int> nodeIndexes = new List<int>();
            public List<long> routeCost = new List<long>();
            public long thisTotalCost;
        }

        public static int[] LnInts()
        {
            var vs = Console.ReadLine().Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            var ins = new int[vs.Length];
            for (int i = 0; i < vs.Length; i++) ins[i] = int.Parse(vs[i]);
            return ins;
        }

        public static int LnInt()
        {
            var vs = Console.ReadLine().Trim();
            return int.Parse(vs);
        }

    }
}