CodeEff/ECCO huggingface dataset:
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

sm=1
sm_lst=[]
for i in range(n):
    sm*=a[i]
    if i>=k:
        sm//=a[i-k]
        if sm > sm_lst[i-1]:
            print("Yes")
        else:
            print("No")
    sm_lst.append(sm)


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

for i in range(k,n):
        if a[i] > a[i-k]:
            print("Yes")
        else:
            print("No")
# Original solution
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
h=[]
for i in range(n-k+1):
    l=1
    for j in range(k):
        l*=A[k+i-1-j]
    h.append(l)
for i in range(n-k):
    if h[i]<h[i+1]:
        print("Yes")
    else:
        print("No")

# Optimized solution
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(n-k):
    if A[k+i]>A[i]:
        print("Yes")
    else:
        print("No")
# Original solution
from functools import reduce

n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
score = [0] * (n+1)

for i in range(k, n+1):
    score[i] = reduce(lambda x, y: x*y, a[i-k:i], 1)
    if i == k:
        continue
    print(('Yes' if score[i-1] < score[i] else 'No'))


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

for i in range(k, n+1):
    if i == k:
        continue
    print(('Yes' if a[i-k-1] < a[i-1] else 'No'))
# Original solution
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))

score = [1 for _ in range(N)]
for i in range(K-1,N):
  for j in range(K):
    score[i] *= A[i-j]
  
for k in range(K-1,N-1):
  if score[k] < score[k+1]:
    print("Yes")
  else:
    print("No")

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

for i in range(K-1,N-1):
  if A[i+1-K] < A[i+1]:
    print("Yes")
  else:
    print("No")
# Original solution
from functools import reduce
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

for k in range(N-K):
    score1 = reduce(lambda x,y: x*y, A[k:K+k])
    score2 = reduce(lambda x, y: x*y, A[k+1:K+k+1])
    if score1 < score2:
        print("Yes")
    else:
        print("No")

# Optimized solution
from functools import reduce
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

for k in range(N-K):
    score1 = A[k]
    score2 = A[K+k]
    if score1 < score2:
        print("Yes")
    else:
        print("No")
# Original solution
#m-solutions2020 c
import sys,math,collections,itertools
input = sys.stdin.readline

N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
ans = 1
for i in range(K):
    ans *= A[i]
pre = ans
for i in range(K,N):
    now = pre * A[i]//A[i-K]
    if now > pre:
        print('Yes')
    else:
        print('No')
    pre = now




# Optimized solution
#m-solutions2020 c
import sys
input = sys.stdin.readline


N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
for i in range(K,N):
    if A[i]>A[i-K]:
        print('Yes')
    else:
        print('No')
# Original solution
# import functools
# import operator
# prod = functools.partial(functools.reduce, operator.mul)

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

score = [1 for _ in range(N)]
for i in range(K):
    for j in range(i+1):
        score[j] *= A[i]
# print(score)

# pre_score = prod(A[:K])
for i in range(K, N):
    for x in range(K):
        score[i-x] *= A[i]
    # score = prod(A[i-K+1:i+1])
    # print(score[i-K+1] , score[i-K])
    if score[i-K+1] > score[i-K]:
        print('Yes')
    else:
        print('No')
    # pre_score = score
# print(score)

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

for i in range(K, N):
    if A[i] > A[i-K]:
        print('Yes')
    else:
        print('No')
# Original solution
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
prod  = 1
for i in range(k-1):
    prod *= a[i]
j = 0
for i in range(k-1,n-1):
    prod *= a[i]
    if prod < (prod//a[j]) * a[i+1]:
        print("Yes")
    else:
        print("No")
    j += 1
    #print(prod, prod//a[j] * a[i+1])
    


# Optimized solution
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
prod  = 1
# for i in range(k-1):
#     prod *= a[i]
j = 0
for i in range(k,n):
    
    if a[i] > a[j]:
        print("Yes")
    else:
        print("No")
    j += 1
    #print(prod, prod//a[j] * a[i+1])
# Original solution
n,k = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))

grade_k = 1
for i in range(k):
    grade_k = grade_k * a[i]

for i in range(k, n):
    if i==k:
        grade_im1 = grade_k
    grade_i = grade_im1 / a[i-k] * a[i]
    #print(grade_im1, grade_i)
    if grade_im1 < grade_i:
        print("Yes")
    else:
        print("No")
    grade_im1 = grade_i



# Optimized solution
n,k = list(map(int, input().split(" ")))
#a = list(map(int, input().split(" ")))
a = []
for i, a_i in enumerate(input().split(" ")):
    a_i = int(a_i)
    a.append(a_i)
    if i<k:
        continue
    #print(a[i-k], a_i)
    if a[i-k] < a_i:
        print("Yes")
    else:
        print("No")
# Original solution
from functools import reduce

n, k = list(map(int, input().split()))
A = list(map(int, input().split()))


res = [0] * (n-k+1)
res[0] = reduce(lambda x, y: x*y , A[0:k+1])

for i in range(1, n-k+1):
    res[i] = res[i-1]//A[i-1]*A[i+k-1]
    print(('Yes' if res[i-1] < res[i] else 'No'))




# Optimized solution
from functools import reduce

n, k = list(map(int, input().split()))
A = list(map(int, input().split()))

for i in range(0, n-k):
    print(('Yes' if A[i] < A[i+k] else 'No'))
# Original solution
NK = list(map(int, input().split(' ')))
N = NK[0]
K = NK[1]
A = list(map(int, input().split(' ')))

score = A[0]
for i in range(1, K):
    score = score * A[i]

for i in range(K, N):
    prev_score = score
    score = score * A[i] / A[i-K]
    if (prev_score < score):
        print('Yes')
    else:
        print('No')


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

for i in range(K, N):
    if (A[i-K] < A[i]):
        print('Yes')
    else:
        print('No')
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
score=[0]*(n-k+1)
for i in range(k-1,n):
    score[i-k+1]=1
    for j in range(k):
        score[i-k+1]*=a[i-j]
for i in range(1,n-k+1):
    if score[i-1]<score[i]:
        print('Yes')
    else:
        print('No')


# Optimized solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(k,n):
    if a[i]>a[i-k]:
        print('Yes')
    else:
        print('No')
# Original solution
N,K = list(map(int,input().split()))
A = [1]+list(map(int,input().split()))

for i in range(1,N+1):
  A[i] = A[i-1]*A[i]

for i in range(K+1, N+1):
  prev = A[i-1] // A[i-K-1]
  now = A[i] // A[i-K]
  if now > prev:
    print('Yes')
  else:
    print("No")

# Optimized solution
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
prev = 1
for i in range(K):
  prev *= A[i]

for i in range(K+1, N+1):
  now = (prev // A[i-K-1])  * A[i-1]
  if now > prev:
    print('Yes')
  else:
    print("No")
  prev = now
# Original solution
# coding: utf-8
import sys
from math import log


def change_into_int(lists):
    tmps = lists.split(' ')
    num_list = []
    for n in tmps:
        num_list.append(int(n))
    return num_list


def create_result(one_list):
    ans = 0
    for n in one_list:
        ans = ans + log(n)
    return ans


def create_lists(data, point):
    num_lists = []
    flag = 0
    count = 0
    while(flag == 0):
        tmp_list = []
        for i in range(point):
            tmp_list.append(data[i+count])
            # print(i+count)
            if i+count == len(data)-1:
                flag = 1
        count = count + 1
        ans = create_result(tmp_list)
        num_lists.append(ans)
    return num_lists


if __name__ == "__main__":
    lines = []
    result_list = []
    # 入力
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    # int
    num1 = change_into_int(lines[0])
    data = change_into_int(lines[1])
    # k個分のlistを作成
    # [2,3,4,5,6]
    # [[2,3],[3,4], ...]
    result_list = create_lists(data, num1[1])
    # # 取り出して積つくる
    # for one_list in lists:
    #     result_list.append(create_result(one_list))
    # 判断
    for n in range(len(result_list)-1):
        if result_list[n] < result_list[n+1]:
            print("Yes")
        else:
            print("No")


# Optimized solution
# coding: utf-8
import sys
from math import log


def change_into_int(lists):
    tmps = lists.split(' ')
    num_list = []
    for n in tmps:
        num_list.append(int(n))
    return num_list


if __name__ == "__main__":
    lines = []
    result_list = []
    # 入力
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    # int
    num1 = change_into_int(lines[0])
    data = change_into_int(lines[1])
    i = 0
    while(True):
        ans = data[i] - data[i+num1[1]]
        if ans < 0:
            print("Yes")
        else:
            print("No") 
        i = i + 1
        if i+num1[1] == len(data):
            break
# Original solution
s = input().split()
N = int(s[0])
K = int(s[1])
A = input().split()

for i in range(K, N):
    m1 = 1
    m2 = 1
    for j in range(K):
        m1 *= int(A[i - j - 1])
        m2 *= int(A[i - j - 0])
    print(('Yes' if m1 < m2 else 'No'))


# Optimized solution
s = input().split()
N = int(s[0])
K = int(s[1])
A = input().split()

for i in range(K, N):
    m1 = int(A[i - K])
    m2 = int(A[i])
    print(('Yes' if m1 < m2 else 'No'))
# Original solution
from itertools import accumulate
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
acc = [0]
acc.extend(list(accumulate(A)))
#print(acc)
scores = []
for i in range(K, N + 1):
  scores.append(acc[i] - acc[i - K])
#print(scores)
for i in range(1, N - K + 1):
  if scores[i] > scores[i - 1]:
    print('Yes')
  else:
    print('No')
  

# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = ['Yes' if A[i] > A[i - K] else 'No' for i in range(K, N)]
print(("\n".join(ans)))
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))

b=list()
x=1

for i in range(k):
    x*=a[i]
b.append(x)
for i in range(k, n):
    x/=a[i-k]
    x*=a[i]
    b.append(x)
x=0
for i in b:
    if x==0:
        x=i
    else:
        if x<i:
            x=i
            print("Yes")
        else:
            x=i
            print("No")


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

for i in range(k,n):
    if (a[i]/a[i-k])>1:
        print("Yes")
    else:
        print("No")
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

prev = 1
for i in range(K):
    prev *= A[i]

idx = 0
for i in range(K, N):
    now = prev // A[idx] * A[i]
    if prev < now:
        ans = "Yes"
    else:
        ans = "No"
    print(ans)

    prev = now
    idx += 1

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

idx = 0
for i in range(K, N):
    if A[idx] < A[i]:
        ans = "Yes"
    else:
        ans = "No"
    print(ans)

    idx += 1
# Original solution
from operator import mul
from functools import reduce

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

for i in range(N-K) :
    x=reduce(mul,A[i:i+K])
    y=reduce(mul,A[i+1:i+K+1])
    if x<y :
        print("Yes")
    else :
        print("No")

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

for i in range(N-K) :
    if A[i]<A[i+K] :
        print("Yes")
    elif A[i]>=A[i+K] :
        print("No")
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [1]
for i in range(n):
    b.append(a[i]*b[-1])
for i in range(n-k):
    if b[i+k+1]/b[i+1] > b[i+k]/b[i]:
        print("Yes")
    else:
        print("No")

# Optimized solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(n-k):
    if a[i] < a[i+k]:
        print("Yes")
    else:
        print("No")
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

for i in range(K+1,N+1):
#  print(A[i-K-1:i-1],A[i-K:i])
  if sum(A[i-K-1:i-1]) < sum(A[i-K:i]):
    print("Yes")
  else:
    print("No")

# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
prev = sum(A[0:K])
for i in range(K+1,N+1):
  curr = prev - A[i-K-1] + A[i-1]
  if prev < curr:
    print("Yes")
  else:
    print("No")
  prev = curr
# Original solution
from operator import mul
from functools import reduce

n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
r = [0] * (n - k + 1)
for i in range(n - k + 1):
    r[i] = reduce(mul, a[i : i + k])

    if i > 0:
        if r[i] > r[i - 1]:
            print("Yes") 
        else: 
            print("No")


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

for i in range(k, n):
    if a[i - k] < a[i]:
        print("Yes")
    else:
        print("No")
# Original solution
n,k = list(map(int,input().split()))
alis = list(map(int,input().split()))

value = 1
for i in range(k):
    value = value * alis[i]

vlis = [value]

for i in range(k,n):
    vlis.append(vlis[i-k]*alis[i]/alis[i-k])

for i in range(1,n-k+1):
    if vlis[i] > vlis[i-1]:
        print('Yes')
    else:
        print('No')

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

for i in range(n-k):
    if(alis[i]<alis[i+k]):
        print('Yes')
    else:
        print('No')
# Original solution
N,K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
def cal(a):
    res = 1
    for i in a:
        res*=i
    return res
score = [cal([j for j in A[i-K:i] ]) for i in range(K,N+1)]
for i in range(len(score)):
    if i==0: continue
    if score[i] > score[i-1]:
        print("Yes")
    else:
        print("No") 

# Optimized solution
N,K = list(map(int, input().split()))
A = [int(i) for i in input().split()]

for i in range(K,N):
    if A[i] > A[i-K]:
        print("Yes")
    else:
        print("No")
# Original solution
# coding: utf-8

import itertools
from functools import reduce
from collections import deque

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

seiseki = deque([])
seiseki2 = []
for i in range(N):
    seiseki.append(A[i])
    if len(seiseki) == K:
        seiseki2.append(reduce(lambda a, b: a * b, seiseki, 1))
        seiseki.popleft()

zenkai = seiseki2[0]
for i in range(1, len(seiseki2)):
    if seiseki2[i] > zenkai:
        print("Yes")
    else:
        print("No")
    zenkai = seiseki2[i]




# Optimized solution
# coding: utf-8

import itertools
from functools import reduce
from collections import deque

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

for i in range(N):
    if i > K-1:
        if A[i] > A[i-K]:
            print("Yes")
        else:
            print("No")
# Original solution
import sys
import copy
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
INF = 1000000000000

n,k = LI()
a = LI()

preval = 1
val = 1
for i in range(n):
    val = val * a[i]
    if(i >= k):
        val = val // a[i-k]
        if(preval < val):
            print('Yes')
        else:
            print('No')
    preval = val

# Optimized solution
import sys
import copy
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
INF = 1000000000000

n,k = LI()
a = LI()

for i in range(n):
    if(i >= k):
        if(a[i] > a[i-k]):
            print('Yes')
        else:
            print('No')
# Original solution
def main():
    N, K = list(map(int, input().split()))
    As = list(map(int, input().split()))
    hyouka = [0]*(N-K+1)
    kekka = 1
    for i in range(N-K+1):
        if i == 0:
            for j in As[i:i+K]:
                kekka *= j
                hyouka[i]=kekka
        else:
            kekka = kekka/As[i-1]*As[i+K-1]
            hyouka[i]=int(kekka)
    #print(hyouka)
    for j in range(len(hyouka)):
        if j>0:
            if hyouka[j] > hyouka[j-1]:
                print('Yes')
            else:
                print("No")

if __name__ == '__main__':
    main()

# Optimized solution
def main():
    N, K = list(map(int, input().split()))
    As = list(map(int, input().split()))
    hyouka = [0]*(N-K+1)
    """
    kekka = 1
    for i in range(N-K+1):
        if i == 0:
            for j in As[i:i+K]:
                kekka *= j
                hyouka[i]=kekka
        else:
            kekka = kekka/As[i-1]*As[i+K-1]
            hyouka[i]=int(kekka)
    #print(hyouka)
    for j in range(len(hyouka)):
        if j>0:
            if hyouka[j] > hyouka[j-1]:
                print('Yes')
            else:
                print("No")
    """
    for i in range(N-K):
        if As[i] < As[i+K]:
            print("Yes")
        else:
            print("No")


if __name__ == '__main__':
    main()
# Original solution
from functools import reduce
from operator import mul

N,K,*A = list(map(int,open(0).read().split()))
base = reduce(mul,A[:K])
for i in range(K,N):
    score = base // A[i-K] * A[i]
    print(("Yes" if base < score else "No"))
    base = score    
    

# Optimized solution
from functools import reduce
from operator import mul

N,K,*A = list(map(int,open(0).read().split()))
base = sum(A[:K])
for i in range(K,N):
    score = base - A[i-K] + A[i]
    print(("Yes" if base < score else "No"))
    base = score
# Original solution
def resolve():
    from collections import deque
    N, K = [int(i) for i in input().split()]
    A = [int(i) for i in input().split()]
    sA = 1
    s = deque()
    for i in range(K):
        s.append(A[i])
        sA *= A[i]
    tmp = sA
    for i in range(K, N):
        sA //= s.popleft()
        s.append(A[i])
        sA *= A[i]
        if tmp < sA:
            print("Yes")
        else:
            print("No")
        tmp = sA


resolve()


# Optimized solution
def resolve():
    from collections import deque
    N, K = [int(i) for i in input().split()]
    A = [int(i) for i in input().split()]
    for i in range(K, N):
        if A[i - K] < A[i]:
            print("Yes")
        else:
            print("No")


resolve()
# Original solution
n,k = list(map(int , input().split()))
sum = 0
a = list(map(int , input().split()))
tmp = 1
for i in range(0,k):
    tmp *= a[i]
for i in range(k,n):
    # print(tmp)
    if tmp*a[i]/a[i-k] > tmp:
        print("Yes")
    else:
        print("No")
    tmp = tmp*a[i]/a[i-k]

# Optimized solution
n,k = list(map(int , input().split()))
sum = 0
a = list(map(int , input().split()))
for i in range(k,n):
    if a[i] > a[i-k]:
        print("Yes")
    else:
        print("No")
# Original solution
N,K = (int(x) for x in input().split())
A = [int(x) for x in input().split()]

#print(N)
#print(K)
#print(A)

preX = 0
nowX = 1

for i in range(K,N+1):
#  print(str(i)+'学期')
  if i == K:
    for x in range(K):
      nowX *= A[x]
  else:
    nowX = int(preX / A[i-K-1]) * A[i-1]
#    print(str(preX) +', '+ str(nowX))
    if preX < nowX:
      print('Yes')
    else:
      print('No')
  preX = nowX
  

# Optimized solution
N,K = (int(x) for x in input().split())
A = [int(x) for x in input().split()]

#print(N)
#print(K)
#print(A)

preX = 0
nowX = 1

for i in range(K+1,N+1):
#  print(str(i)+'学期')
#  if i == K:
#    for x in range(K):
#      nowX *= A[x]
#  else:
#    nowX = int(preX / A[i-K-1]) * A[i-1]
#    print(str(preX) +', '+ str(nowX))
#    if preX < nowX:
#      print('Yes')
#    else:
#      print('No')
#  preX = nowX

  if A[i-K-1] < A[i-1]:
    print('Yes')
  else:
    print('No')
# Original solution
n, k = list(map(int, input().split()))

a = list(map(int, input().split()))

t = 0
s = 1
u = 0
k_k = k
temp = []
while k != n+1:
  for i in range(t, k):
    alpha = a[i]
    s = s * alpha
  temp.append(s)
  k = k + 1
  s = 1
  t = t+1
  if u != 0:
    t_s = temp[u-1]
    t_t = temp[u]
    if t_s < t_t:
      print("Yes")
      u = u + 1
    else:
      print("No")
      u = u + 1
  else:    
    u = u + 1    





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

a = list(map(int, input().split()))

for i in range(k, n):
  if a[i-k] < a[i]:
    print("Yes")
  else:
    print("No")
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

num = 1
for i in range(n):
    pre_num = num
    num *= a[i]
    if i >= k:
        num /= a[i-k]
    if i >= k and num > pre_num:
        print('Yes')
    elif i >= k and num <= pre_num:
        print('No')


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

for i in range(n):
    if i >= k:
        if a[i] > a[i-k]:
            print('Yes')
        else:
            print('No')
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))

score = [1 for _ in range(n-k+1)]
temp = 1
for i in range(k):
    temp *= a[i]
score[0] = temp
for j in range(1,n-k+1):
    score[j] = score[j-1]*a[j+k-1]//a[j-1]

#print(score)
for i in range(1,n-k+1):
    if score[i-1] < score[i]:
        print('Yes')
    else:
        print('No')
    

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

for i in range(k,n):
    if a[i-k] < a[i]:
        print('Yes')
    else:
        print('No')
# Original solution
#n=int(input())
n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
mul=1
for i in range(k):
  mul=mul*l[i]
z=mul
j=0
for i in range(k,n):
  z=z//l[j]
  z=z*l[i]
  if z>mul:
    print('Yes')
  else:
    print('No')
  j+=1
  mul=z

# Optimized solution
#n=int(input())
n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
mul=1
for i in range(k):
  mul=mul+l[i]
z=mul
j=0
for i in range(k,n):
  z=z-l[j]
  z=z+l[i]
  if z>mul:
    print('Yes')
  else:
    print('No')
  j+=1
  mul=z
# Original solution
INT = lambda: int(eval(input()))
INTM = lambda: list(map(int,input().split()))
STRM = lambda: list(map(str,input().split()))
STR = lambda: str(eval(input()))
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n,k=INTM()
    A=LIST()
    #flg=True
    Ave=[0]*(n-k+1)
    for i in range(n-k+1):
        Ave[i]=float(sum(A[i:i+k])/k)
    for i in range(n-k):
        if Ave[i+1]>Ave[i]:
            print('Yes')
        else:
            print('No')
        
    
    
if __name__ == '__main__':
    do()

# Optimized solution
INT = lambda: int(eval(input()))
INTM = lambda: list(map(int,input().split()))
STRM = lambda: list(map(str,input().split()))
STR = lambda: str(eval(input()))
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n,k=INTM()
    A=LIST()
    for i in range(n-k):
        #print(A[i],A[i+k])
        if A[i]<A[i+k]:
            print('Yes')
        else:
            print('No')
        
    
    
if __name__ == '__main__':
    do()
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

t = 1
for i in range(K):# A[0] ~ A[K-1]
  t *= A[i]
  
for i in range(K, N):
  temp = t // A[i-K] * A[i]
  if t < temp:
    print('Yes')
  else:
    print('No')
  t = temp


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

for i in range(K, N):
  if A[i-K] < A[i]:
    print('Yes')
  else:
    print('No')