CodeEff/ECCO huggingface dataset:
# Original solution
from collections import Counter

M = 998244353
N, S = list(map(int, input().split()))
A = list(map(int, input().split()))

ans = 0
prev = Counter()
for i, a in enumerate(A, 1):
  curr = Counter({a+s: c for s, c in list(prev.items()) if a+s<=S})
  curr.update({a:i})
  ans = (ans + curr[S]*(N-i+1))%M
  curr.update(prev)
  prev = curr

print(ans)
    

# Optimized solution
M = 998244353
N, S = list(map(int, input().split()))

ans = 0
prev = [0]*S
for i, a in enumerate(map(int, input().split()), 1):
  if a > S:
    continue
  prev[0] = i
  ans = (ans + prev[S-a]*(N-i+1)) % M
  for j, s in enumerate(prev[:S-a], a):
    prev[j] += s
print(ans)
# Original solution
def setM():
    K2 = K // 2
    k = K // 2
    while k:
        m = int(("1" * (K2 - k) + "0" * (K2 + k)) * 3001, 2)
        M.append((k, m))
        k //= 2

def modp(n):
    K2 = K // 2
    k = K // 2
    for k, m in M:
        n = (n & (~m)) + ((n & m) >> (K2 + k)) * ((1 << K2 + k) % P)
    return n

K = 64
P = 998244353
mm = (1 << K * 3001) - 1
mmm = (1 << K) - 1
M = []
setM()
N, S = list(map(int, input().split()))
A = [int(a) for a in input().split()]
s = 0
ans = 0
for a in A:
    s += 1
    s += s << a * K
    s &= mm
    s = modp(s)
    ans += (s >> S * K) & mmm

print((ans % P))

# Optimized solution
def setM():
    k = K2 // 2
    while k:
        m = int(("1" * (K2 - k) + "0" * (K2 + k)) * 3001, 2)
        M.append((k, m, ~m, (1 << K2 + k) % P))
        k //= 2

def modp(n):
    for k, m, tm, a in M:
        n = (n & tm) + ((n & m) >> K2 + k) * a
    return n

K = 64
K2 = K // 2
P = 998244353
mm = (1 << K * 3001) - 1
mmm = (1 << K) - 1
M = []
setM()
N, S = list(map(int, input().split()))
A = [int(a) for a in input().split()]
s = 0
ans = 0
for a in A:
    s += 1
    s += s << a * K
    s &= mm
    s = modp(s)
    ans += (s >> S * K) & mmm

print((ans % P))
# Original solution
def setM():
    k = K2 // 2
    while k:
        m = int(("1" * (K2 - k) + "0" * (K2 + k)) * 3001, 2)
        M.append((k, m, ~m, (1 << K2 + k) % P))
        k //= 2

def modp(n):
    for k, m, tm, a in M:
        n = (n & tm) + ((n & m) >> K2 + k) * a
    return n

K = 64
K2 = K // 2
P = 998244353
mm = (1 << K * 3001) - 1
mmm = (1 << K) - 1
M = []
setM()
N, S = list(map(int, input().split()))
A = [int(a) for a in input().split()]
s = 0
ans = 0
for a in A:
    s += 1
    s += s << a * K
    s &= mm
    s = modp(s)
    ans += (s >> S * K) & mmm

print((ans % P))

# Optimized solution
def setM():
    k = K2 // 2
    while k:
        m = int(("1" * (K2 - k) + "0" * (K2 + k)) * 3001, 2)
        M.append((k, m, ~m, (1 << K2 + k) % P))
        k //= 2
        break

def modp(n):
    for k, m, tm, a in M:
        n = (n & tm) + ((n & m) >> K2 + k) * a
    return n

K = 64
K2 = K // 2
P = 998244353
mm = (1 << K * 3001) - 1
mmm = (1 << K) - 1
M = []
setM()
N, S = list(map(int, input().split()))
A = [int(a) for a in input().split()]
s = 0
ans = 0
for a in A:
    s += 1
    s += s << a * K
    s &= mm
    s = modp(s)
    ans += (s >> S * K) & mmm

print((ans % P))
# Original solution
N, i = list(map(int,input().split()))
print((N-i+1))

# Optimized solution
a, b = list(map(int, input().split()))
print((a - b + 1))
# Original solution
train_len, target_vehicle = list(map(int, input().split()))

target_from_backside = train_len - (target_vehicle - 1)
print(target_from_backside)


# Optimized solution
n, i = list(map(int, input().split()))

print((n - i + 1))
# Original solution
import os
import sys
import heapq

def main():
    H , K = list(map(int , input().split()))
    n_list = [s for s in input().split()]
    n_list = list(map(int,n_list))
    #print (n_list)
    #c = sum(int(i) for i in list)
    list_small = []
    new_list = []
    if K >= len(n_list) :
        print((str(0)))
    elif K == 0 :
        c = sum(int(i) for i in n_list)
        print((str(c)))
    else :
        list_small = heapq.nlargest(K,n_list)
        list_small = list(map(int,list_small))
        #print (list_small)
        #new_list = list(set(n_list)-set(list_small))
        new_list = list_difference(n_list, list_small)
        #print (list_small)
        #print (new_list)
        c = sum(int(i) for i in new_list)
        print((str(c)))
    #print (str(X))
def list_difference(list1, list2):
    result = list1.copy()
    for value in list2:
        if value in result:
            result.remove(value)

    return result

if __name__ == '__main__':
    main()

# Optimized solution
import os
import sys
import heapq

def main():
    H , K = list(map(int , input().split()))
    n_list = [s for s in input().split()]
    n_list = list(map(int,n_list))
    #print (n_list)
    #c = sum(int(i) for i in list)
    list_small = []
    new_list = []
    if K >= len(n_list) :
        print((str(0)))
    elif K == 0 :
        c = sum(int(i) for i in n_list)
        print((str(c)))
    else :
        list_small = heapq.nlargest(K,n_list)
        list_small = list(map(int,list_small))
        #print (list_small)
        #new_list = list(set(n_list)-set(list_small))
        #new_list = list_difference(n_list, list_small)
        #print (list_small)
        #print (new_list)
        c = sum(int(i) for i in n_list)
        d = sum(int(i) for i in list_small)
        print((str(c-d)))
    #print (str(X))

if __name__ == '__main__':
    main()
# Original solution
from math import ceil
from sys import stdin
n,k = list(map(int,stdin.readline().split()))
h = sorted(list(map(int,stdin.readline().split())))
ans = 0
for i in range(0,len(h)-k): ans += h[i]
print(ans)

# Optimized solution
special_moves = input().split(" ")

_, special_moves = int(special_moves [0]), int(special_moves [1])

health= input().split(" ")
health= [int(h) for h in health]
health.sort(reverse=True)
print((sum(health[special_moves:])))
# Original solution
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H.sort()
for i in range(K):
    H = H[:-1]
print((sum(H)))

# Optimized solution
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H.sort()
if K != 0:
    H = H[:-K]
print((sum(H)))
# Original solution
#!/user/bin/env python
#pythonプログラムであることを示している

# -*- coding: utf-8 -*-
"""
このプログラムはPythonを書く際のテンプレとなっています。これをコピペしてコーディングを行なってください。
なお字下げしないこと！！
"""

__author_ = 'Maruta Yuzuha'
__version_ = '1.0.0'
__date__ = '2019/12/25'

def main():
    """
    ここでプログラムの解説を行う
     >>main()
    Hello world.
    0
    """
    s = list(map(int, input().split()))
    t = list(map(int, input().split()))

    a = 0  #勝つまでの回数
    b = s[0]#何匹か
    d = s[1]#必殺技の回数
    # c = sum(t)
    # d = int(s[1])
    # for i in range(int(s[1])):
    #     if sum(t) != 0:
    #         if d != 0:
    #             c -= max(t)
    #             for j in range(int(s[0])):
    #                 if max(t) == t[j]:
    #                     t[j] = 0
    #             d -= 1
    #         else:
    #             break
    e = 0  #Max
    f = 0# Maxのいち
    for j in range(d):  #必殺技の回数
        c = sum(t)
        if c != 0:
            for i in range(b):
                if e < t[i]:
                    e = t[i]
                    f = i
            t[f] = 0
            e = 0
            f = 0
        else:
            break
    a += sum(t)
    print(a)
    return 0

if __name__ == '__main__':
    #上記のifの記述によってこのスクリプトファイルが起動された時だけ実行する部分になる。
    #ちなみにスクリプトが "モジュールとして"インポートされた時には実行されない、

    #単体テスト:モジュールのdocstring(ドキュメンテーション文字列)に記載された全ての対話実行例が書かれている通りに動作するかを確認
    #python ファイル名 -v
    import doctest
    doctest.testmod()

    #実際にmain()を呼び出して、結果を得て、その結果でPythonシステムを終える
    import sys
    sys.exit(main())

# Optimized solution
#!/user/bin/env python
#pythonプログラムであることを示している

# -*- coding: utf-8 -*-

def main():
    """
    ここでプログラムの解説を行う
     >>main()
    Hello world.
    0
    """
    s = list(map(int, input().split()))
    t = list(map(int, input().split()))
    t.sort(reverse=True)
    a = 0  #勝つまでの回数
    b = s[0]#何匹か
    d = s[1]#必殺技の回数
    f = 0# Maxのいち
    # for j in range(d):  #必殺技の回数
    #     c = sum(t)
    #     if c != 0:
    #         g = max(t)
    #         for i in range(b):
    #             if g == t[i]:
    #                 t[i] = 0
    #                 break
    #         t[f] = 0
    #         f = 0
    #     else:
    #         break
    c = sum(t)
    for i in range(d):
        if c != 0:
            c -= t[i]
            t[i] = 0
        else:
            break
    a += sum(t)
    print(a)
    return 0

if __name__ == '__main__':

    #実際にmain()を呼び出して、結果を得て、その結果でPythonシステムを終える
    import sys
    sys.exit(main())
# Original solution
A = list(map(int , input().split()))
B = list(map(int , input().split()))
if A[0] < A[1]:
    print((0))
else:
    B.sort(reverse=True)
    for i in range(A[1]):
        B.remove(max(B))
    print((sum(B)))

# Optimized solution
A = list(map(int , input().split()))
B = list(map(int , input().split()))
if A[0] < A[1]:
    print((0))
else:
    B.sort(reverse=True)
    del B[0:A[1]]
    print((sum(B)))
# Original solution
N, K = list(map(int, input().split()))
Hs = list(map(int, input().split()))
Hs.sort(reverse=True)
if K > N:
  print((0))
else:
  for i in range(K):
    Hs[i] = 0
  print((sum(Hs)))

# Optimized solution
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
h = sorted(h, reverse=True)
print((sum(h[k:])))
# Original solution
N, K = list(map(int, input().split()))
List = list(map(int, input().split()))
List.sort()
List.reverse()
ans=0

if len(List) == K-1:
    print((0))
    quit()

def Check(List,ans):
    if sum(List) <= 0:
        print(ans)
        quit()

#print(List)

List=List[K:]

Check(List,ans)

j=0
while 1==1:
    ans+=List[j]
    List[j]=0
    Check(List,ans)
    j+=1
    

# Optimized solution
n, k = list(map(int,input().split()))
h = list(map(int,input().split()))

h.sort(reverse=True)
for i in range(0,min(k,len(h))):
    h[i] = 0
hp = 0
for j in range(k,n):
    hp += h[j]

print(hp)
# Original solution
(N, K) = list(map(int, input().split()))
H = list(map(int, input().split()))

H = sorted(H, reverse=True)
while (K > 0) and (len(H) > 0):
    H.pop(0)
    K -= 1
print((sum(H)))

# Optimized solution
(N, K) = list(map(int, input().split()))
H = list(map(int, input().split()))

H = sorted(H, reverse=True)
if K >= len(H):
    print((0))
else:
    del H[0:K]
    print((sum(H)))
# Original solution
N, K = list(map(int, input().split()))
*H, = list(map(int, input().split()))
H.sort(reverse=True)
ans = 0
if len(H) - K <= 0:
    print((0))
else:
    ans += sum(H[K:])
    print(ans)

# Optimized solution
N, K = list(map(int, input().split()))
*H, = list(map(int, input().split()))
H.sort(reverse=True)
if len(H) - K <= 0:
    print((0))
else:
    print((sum(H[K:])))
# Original solution
N, K=list(map(int, input().split()))
H=list(map(int, input().split()))

if K>=N:
	print((0))
	exit()    
H.sort()
for i in range(K):
	H[N-1-i]=0
    
print((sum(H)))

# Optimized solution
N, K=list(map(int, input().split()))
H=list(map(int, input().split()))

if K>=N:
	print((0))
	exit()
#HPの多い順に必殺技を使用
H.sort()
for i in range(K):
	H[N-1-i]=0
    
print((sum(H)))
# Original solution
a = list(map(int,input().split()))
N = a[0]
K = a[1]
H = list(map(int,input().split()))
H.sort(reverse=True)
ans = 0
if K >= N:
    print((0))
else:
    for i in range(K):
        b = H.pop(0)
    ans = sum(H)
    print(ans)

# Optimized solution
a = list(map(int,input().split()))
N = a[0]
K = a[1]
H = list(map(int,input().split()))
H.sort(reverse=True)
ans = 0
MOD = 10**9 + 7
if K >= N:
    print((0))
else:
    for i in range(K,N):
        ans += H[i]

    print(ans)
# Original solution
def main():
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))

    if n <= k:
        print((0))
    elif k > int((n - 1) /2):
        sum_ = sum(a)
        for i in range(n - k):
            a.remove(min(a))
        print((sum_ - sum(a)))
    else:
        for i in range(k):
            a.remove(max(a))

        print((sum(a)))


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    n, k = list(map(int, input().split()))
    h = list(map(int, input().split()))
    h = sorted(h, reverse=True)

    if n <= k:
        print((0))
    else:
        print((sum(h[k:])))


if __name__ == '__main__':
    main()
# Original solution
#template
from collections import Counter
def inputlist(): return [int(j) for j in input().split()]
N,K = inputlist()
H = inputlist()
H.sort()
H.reverse()
ans = 0
for i in range(K,N):
    ans += H[i]
print(ans)

# Optimized solution
#template
def inputlist(): return [int(k) for k in input().split()]
#template
N,K = inputlist()
H = inputlist()
if K >= N:
    print((0))
    exit()
H.sort(reverse=True)
ha = H[K:]
print((sum(ha)))
# Original solution
N, K = list(map(int, input().split()))
H = [int(h) for h in input().split()]

if len(H) <= K:
  print((0))
  exit()
  
for i in range(K):
  H.remove(max(H))
print((sum(H)))

# Optimized solution
N, K = list(map(int, input().split()))
H = [int(h) for h in input().split()]
H = list(sorted(H, reverse = True))

if len(H) <= K:
  print((0))
else:
  del H[0:K]
  print((sum(H)))
# Original solution
import sys
import heapq
input = sys.stdin.readline

N, K = list(map(int, input().split()))

Hs = [-int(c) for c in input().split()]
heapq.heapify(Hs)

for _ in range(min(K, len(Hs))):
    heapq.heappop(Hs)

print((-sum(Hs)))


# Optimized solution
import sys

input = sys.stdin.readline

N, K = list(map(int, input().split()))

Hs = sorted(map(int, input().split()))

print((sum(Hs[:-K if K > 0 else len(Hs)])))
# Original solution
# coding: utf-8
import heapq
n,k = [int(x) for x in input().split()]
h = sorted([int(x) for x in input().split()])
#print(h)
s = 0
if k >= n:
    print((0))
else:
    h = h[:n-k]
    for j in h:
        s += j
    print(s)

# Optimized solution
# coding: utf-8
n,k = [int(x) for x in input().split()]
h = sorted([int(x) for x in input().split()])
if k >= n:
    print((0))
else:
    count = 0
    for i in range(n-k):
        count += h[i]
    print(count)
# Original solution
N, K = [int(_) for _ in input().split()]
H = [int(_) for _ in input().split()]
list_H = sorted(H, reverse=True)
if len(H) < K:
    print((0))
else:
    for k in range(K):
        if len(list_H) > 0:
            list_H.pop(0)
    print((sum(list_H)))


# Optimized solution
N, K = [int(_) for _ in input().split()]
H = [int(_) for _ in input().split()]
H.sort(reverse=True)
print((sum(H[K:])))
# Original solution
import itertools
import math
import fractions
import functools
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))

h.sort(reverse=True)
if k < n:
    for i in range(k):
        h[i] = 0
else:
    h = [0] * len(h)
print((sum(h)))


# Optimized solution
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))

h.sort(reverse=True)

if n >= k:
    for i in range(k):
        h[i] = 0
    print((sum(h)))
else: print((0))
# Original solution
n, k = list(map(int, input().split()))
h = list(map(int, input().split()))

# hを体力の小さい順にソート
h.sort()

# 全てのモンスターに必殺技を使える場合
if k >= len(h):
    print('0')
# 全てのモンスターに必殺技を使えない場合
# 体力の大きいモンスター順からk体削除
else:
    new_h = h[:len(h)-k]
    print((sum(new_h)))


# Optimized solution
n, k = list(map(int, input().split()))
h=list(map(int,input().split()))

# 体力の大きい順にソート
h=sorted(h,reverse=True)

# k > len(h) ならば　空のリストになるので
# k >= len(h) と　それ以外の場合分けが必要なくなる
h=h[k:]
print((sum(h)))
# Original solution
import math
n,k = list(map(int,input().split()))
als = list(map(int,input().split()))
als.sort(reverse=1)
ans = 0
for i in range(k,n):
    ans += als[i]
print(ans)



# Optimized solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort(reverse=1)
print((sum(a[k:])))
# Original solution
n,k=list(map(int,input().split()))
hps=list(map(int,input().split()))
hps.sort()
if k>n:
  print((0))
elif k==n:
  print((0))
else:
  ans=0
  for i in range(k):
    hps=hps[0:-1]
  ans+=sum(hps)
  print(ans)

# Optimized solution
n,k=list(map(int,input().split()))
hps=list(map(int,input().split()))
hps.sort()
if k>n:
  print((0))
elif k==n:
  print((0))
else:
  ans=0
  for i in range(k):
    hps.pop()
  ans+=sum(hps)
  print(ans)
# Original solution
n, k = list(map(int , input().split()))
hn = [int(num) for num in input().split()]

hn.sort(reverse = True)
for i in range(k):
  if len(hn) > 0:
    hn = hn[1:]
    
print((sum(hn)))

# Optimized solution
n, k = list(map(int , input().split()))
hn = [int(num) for num in input().split()]

hn.sort(reverse = True)
if len(hn) > k:
  print((sum(hn[k:])))
else :
  print((0))
# Original solution
eneNum, spNum = list(map(int, input().split()))
eneHp = list(map(int, input().split()))
eneHpList = list(eneHp)

count = 0
for i in range(spNum):
    if len(eneHpList) > 0:
        maxEneHp = max(eneHpList)
        eneHpList.remove(maxEneHp)
count = sum(eneHpList)

print(("{}".format(count)))

# Optimized solution
eneNum, spNum = list(map(int, input().split()))
eneHp = list(map(int, input().split()))
eneHpList = list(eneHp)

# TLE
#count = 0
#for i in range(spNum):
#    if len(eneHpList) > 0:
#        maxEneHp = max(eneHpList)
#        eneHpList.remove(maxEneHp)

# new method
eneHpList.sort()
eneHpList.reverse()
del eneHpList[0:min([spNum, len(eneHpList)])]
count = sum(eneHpList)

print(("{}".format(count)))
# Original solution
n,k = list(map(int,input().split()))
li = list(map(int,input().split()))

for i in range(k):
    m = li.index(max(li))
    li[m] = 0

print((sum(li)))

# Optimized solution
n,k = list(map(int,input().split()))
li = list(map(int,input().split()))
ls = sorted(li, reverse=True)
if k >= len(li):
    print((0))
else:
    print((sum(ls[k:])))
# Original solution
NK=input().split()
N=int(NK[0])
K=int(NK[1])
Hlis=list(map(int,input().split()))
ans=0

if K>=N:
    print((0))
else:
    for i in range(N-K):
        mini=Hlis.index(min(Hlis))
        ans+=Hlis[mini]
        Hlis.pop(mini)
    print(ans)

# Optimized solution
NK=input().split()
N=int(NK[0])
K=int(NK[1])
Hlis=list(map(int,input().split()))
ans=0

if K>=N:
    print((0))
else:
    Hlis.sort()
    for i in range(N-K):
        ans+=Hlis[i]
    print(ans)
# Original solution
n, k = list(map(int, input().split()))
h = sorted(list(map(int, input().split())))

for i in range(k):
    if n > i:
        del h[n - i - 1]

HP = sum(h)
print(HP)

# Optimized solution
n, k = list(map(int, input().split()))
h = sorted(list(map(int, input().split())))

for i in range(min(n, k)):
        del h[n - i - 1]

HP = sum(h)
print(HP)
# Original solution
N,K=list(map(int,input().split()))
H=[int(x) for x in input().split()]
if N<=K:
    print((0))
else:
    H.sort(reverse=True)
    for j in range(K):
        H.pop(0)
    print((sum(H)))


# Optimized solution
N,K=list(map(int,input().split()))
H=[int(x) for x in input().split()]
if N<=K:
    print((0))
else:
    H.sort(reverse=True)

    del H[0:K]
    print((sum(H)))
# Original solution
import itertools
import fractions
def main():
  a,b = list(map(int,input().split()))
  print((a*b if a<10 and b<10 else -1))
if __name__ == '__main__':
  main()

# Optimized solution
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
#from fractions import gcd
#from itertools import combinations # (string,3) 3回
#from collections import deque
from collections import defaultdict
#import bisect
#
#    d = m - k[i] - k[j]
#    if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#

import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
  return list(map(int,input().split()))
def I():
  return int(eval(input()))
a,b = readInts()
if 1 <= a <= 9 and 1 <= b <= 9:
    print((a*b))
else:
    print((-1))
# Original solution
import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
INF = float('inf')

def sol():
    A, B = list(map(int, input().split()))
    if 1 <= A <= 9 and 1 <= B <= 9:
        print((A * B))
    else:
        print((-1))


sol()

# Optimized solution
A,B=list(map(int,input().split()))
print((-1 if max(A,B)>9 else A*B))
# Original solution
def main():
    a,b = list(map(str, input().split()))

    if len(a) == 1 and len(b) == 1:
        print((int(a) * int(b)))
    else:
        print("-1")


if __name__ == "__main__":
    main()


# Optimized solution
def main():
    a,b = list(map(int, input().split()))
    print((a * b if a < 10 and b < 10 else "-1"))


if __name__ == "__main__":
    main()
# Original solution
import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)
def getN():
    return int(eval(input()))
def getList():
    return list(map(int, input().split()))

def solve():

    return

def main():
    a, b = getList()
    if a <= 9 and b <= 9:
        print((a*b))
    else:
        print((-1))



if __name__ =="__main__":
    main()

# Optimized solution
def getList():
    return list(map(int, input().split()))
a, b = getList()
if a > 9 or b > 9:
  print((-1))
else:
  print((a*b))
# Original solution
A, B = list(map(int, input().split()))

if A >= 10 or B >= 10:
    print((-1))
    exit()

ans = A * B
print(ans)

# Optimized solution
A, B = list(map(int, input().split()))

if 1 <= A <= 9 and 1 <= B <= 9:
    print((A*B))
else:
    print((-1))
# Original solution
import sys
from collections import Counter

sys.setrecursionlimit(10**7)
 
inf = 1<<100
 
def solve():
    a, b, c = list(map(int, input().split()))

    print(('Yes' if a <= c <= b else 'No'))

if __name__ == '__main__':
    solve()

# Optimized solution
import sys
 
def solve():
    a, b, c = list(map(int, input().split()))
    
    print(('Yes' if a <= c <= b else 'No'))

if __name__ == '__main__':
    solve()
# Original solution
A,B,C = list(map(int,input().split()))

if A <= C <= B:
    print("Yes")
else:
    print("No")

# Optimized solution
A,B,C = list(map(int,input().split()))

print(("Yes" if A <= C <= B else "No"))
# Original solution
N = int(eval(input()))
A = []
for _ in range(N):
  A.append(int(eval(input())))
  
cnt = A[0] - 1
cant_use = 1
for a in A[1:]:
  wk = a
  if wk == cant_use+1:
    #cnt += 1
    cant_use += 1
    continue
    
  while wk > cant_use:
    if wk % (cant_use+1) == 0:
      wk -= cant_use + 2
    else:
      wk -= cant_use + 1
    cnt += 1
print(cnt)

# Optimized solution
N = int(eval(input()))
A = []
for _ in range(N):
  A.append(int(eval(input())))
  
cnt = A[0] - 1
cant_use = 1
for a in A[1:]:
  wk = a
  if wk == cant_use+1:
    #cnt += 1
    cant_use += 1
    continue
    
  if wk % (cant_use+1) == 0:
    wk -= cant_use + 2
    cnt += 1
  cnt += wk // (cant_use+1)
print(cnt)
# Original solution
n,*a=list(map(int,open(0)))
b,c=1,0
for i in a:
  if i>b:
    c+=(i-1)//b
    b+=b<2
  elif i==b:
    b+=1
print(c)

# Optimized solution
n,*a=list(map(int,open(0)))
b,c=1,0
for i in a:
  c+=~-i//b*(i>b)
  b+=b<2or i==b
print(c)