CodeEff/ECCO huggingface dataset:
# Original solution
N,K=list(map(int,input().split()))
A=[int(s) for s in input().split()]
dp=[0]*(N-K+2)
dp[1]=1
for j in range(K):
    dp[1]*=A[j]
for i in range(1,N-K+1):
    dp[i+1]=dp[i]*A[K+i-1]/A[i-1]
    if dp[i+1]>dp[i]:
        print('Yes')
    else:
        print('No')

# Optimized solution
N,K=list(map(int,input().split()))
A=[int(s) for s in input().split()]
for i in range(N-K):
    if A[K+i]/A[i]>1:
        print('Yes')
    else:
        print('No')
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[1]
for i in range(k):b[0]*=a[i]
for i in range(k,n):
  b.append(b[-1]*a[i]//a[i-k])
for i in range(len(b)-1):
  if b[i]<b[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
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return eval(input())
def LS(): return input().split()


INF = float('inf')


n, k = LI()
a = LI()
base = 1
for elem in a[:k]:
    base *= elem
for i in range(k, n):
    rate = a[i] / a[i-k]
    # print(rate)
    if rate > 1:
        ans = 'Yes'
    else:
        ans = 'No'
    print(ans)


# Optimized solution
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return eval(input())
def LS(): return input().split()


INF = float('inf')


n, k = LI()
a = LI()
base = 1
for i in range(k, n):
    rate = a[i] / a[i-k]
    if rate > 1:
        ans = 'Yes'
    else:
        ans = 'No'
    print(ans)
# Original solution
import operator
import functools
prod = functools.partial(functools.reduce, operator.mul)
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

l = n - k + 1
lis = [0]*l
#0, 1, 2
for i in range(l):
  lis[i] = prod(a[i:i+k])

for i in range(n - k):
  if lis[i] < lis[i + 1]:
    print("Yes")
  else:
    print("No")

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

#0, 1
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()))
a = 1
for i in range(k):
    a *= A[i]
ans = a
for i in range(k,n):
    a = a//A[i-k] * A[i]
    if ans < a: print("Yes")
    else: print("No")
    ans = a

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

# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
pre_score = 1
for i in range(k, n):
  after_score = pre_score*a[i]/a[i-k]
  if after_score > pre_score:
    print('Yes')
  else:
    print('No')
# Original solution
N,K=list(map(int,input().split()))
a_list=list(map(int,input().split()))
a_mul = [1]
for i,a in enumerate(a_list):
  a_mul.append(a_mul[i] * a)

for i in range(K+1,N+1):
  iscore = a_mul[i]//a_mul[i-K]
  i_score = a_mul[i-1]//a_mul[i-1-K]
  print(('Yes' if iscore > i_score else 'No'))

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

for i in range(K,N):
  iscore = a_list[i]
  i_score = a_list[i-K]
  print(('Yes' if iscore > i_score else 'No'))
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

# import functools
# import operator
# prod = functools.partial(functools.reduce, operator.mul)

# i=K+1の時、直近K回の期末テストの点数
# p_K = prod(A[:K])
p_K = 1
for i in range(K):
    p_K *= A[i]

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


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

# import functools
# import operator
# prod = functools.partial(functools.reduce, operator.mul)

# i=K+1の時、直近K回の期末テストの点数
# p_K = prod(A[:K])
p_K = 1

for i in range(K, N):
    t = A[i] / A[i-K]
    p_Kp1 = p_K * t
    if p_K < p_Kp1:
        print('Yes')
    else:
        print('No')
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
m = 1
for i in range(k):
	m *= a[i]
tmp = m
for i in range(k, n):
	m *= a[i]
	m //= a[i - k]
	if m > tmp:
		print('Yes')
	else:
		print('No')
	tmp = m


# 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()))
x = []
for i in range(n-k+1):
    tmp = 1
    for j in range(k):
        tmp *= a[i+j]
    x.append(tmp)

for i in range(n-k):
    if x[i] < x[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[i] < a[i+k]:
        print("Yes")
    else:
        print("No")
# Original solution
N=list(map(int,input().split()))
A=list(map(int,input().split()))
n=N[0]
k=N[1]
aves=[]
for x in range(n-k+1):
    ave=1
    for i in range(x,k+x):
        ave=ave*A[i]
    aves.append(ave)
for y in range(len(aves)-1):
    if aves[y]<aves[y+1]:
        print("Yes")
    else:
        print("No")

# Optimized solution
N=list(map(int,input().split()))
A=list(map(int,input().split()))
n=N[0]
k=N[1]
for i in range(n-k):
    if A[i]<A[k+i]:
        print("Yes")
    else:
        print("No")
# Original solution
# cook your dish here
n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
scores = []
start = k-1
kk = k
i = k-1
while i<n:
    cnt = kk
    temp = 0
    ans = 1
    while cnt>0:
        ans = ans*l[i-temp]
        temp=temp+1
        cnt=cnt-1
    scores.append(ans)
    i=i+1
if len(scores)==1:
    print("Yes")
else:
    i = 1
    while i<len(scores):
        if scores[i]>scores[i-1]:
            print("Yes")
        else:
            print("No")
        i = i+1

# Optimized solution
# cook your dish here
n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
for i in range(k, n):
    if l[i-k] < l[i]:
        print("Yes")
    else:
        print("No")
# Original solution
N,K = list(map(int,input().split()))
A = list(map(int, input().split()))
sum = 1
last = 1
sw = 0
for num in range(K):
  last *= A[num]
for i in range(1,N-K+1):
  for j in range(K):
    sum *= A[i+j]
    if last < sum:
      print("Yes")
      sw = 1
      break
  if sw ==0:
    print("No")
  last = sum
  sum = 1
  sw = 0

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

for i in range(0,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()))
def last_k(a, i):
    p = 1
    for j in range(k):
        p=p*a[i-j]
    return p
seed = last_k(a, k-1)
for i in range(n-k):
    if seed < int(seed*a[i+k]/a[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+k] > a[i]:
        print('Yes')
    else:
        print('No')
# Original solution
import functools
import operator


def prod(arr):
    return functools.reduce(operator.mul, arr)


def main():
    N, K = (int(x) for x in input().split(" "))
    A = [int(x) for x in input().split(" ")]
    lastest_score = prod(A[0:K])
    result = ["No"] * (N-K+1)
    for i in range(1, N-K+1):
        current_score = lastest_score - A[i-1] + A[i + K-1]
        if lastest_score < current_score:
            result[i] = "Yes"
        lastest_score = current_score
    [print(x) for x in result[1:]]


if __name__ == '__main__':
    main()


# Optimized solution
def prod(arr):
    s = 0
    for x in arr:
        s += x
    return s


def main():
    N, K = (int(x) for x in input().split(" "))
    A = [int(x) for x in input().split(" ")]
    lastest_score = prod(A[0:K])
    result = ["No"] * (N-K+1)
    for i in range(1, N-K+1):
        current_score = lastest_score - A[i-1] + A[i + K-1]
        if lastest_score < current_score:
            result[i] = "Yes"
        lastest_score = current_score
    [print(x) for x in result[1:]]


if __name__ == '__main__':
    main()
# Original solution
n, k = list(map(int, input().split(' ')))
a = [int(tmp) for tmp in input().split(' ')]
point = 1

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

for i in range(n - k):
    f_point = point // a[i] * a[k+i]
    if point < f_point:
        print('Yes')
    else:
        print('No')
    
    point = f_point


# Optimized solution
n, k = map(int, input().split(' '))
a = [int(tmp) for tmp in input().split(' ')]
[print('Yes') if a < b else print('No') for a, b in zip(a[:n - k], a[k:])]
# Original solution
# 入力
N,K = list(map(int, input().split()))
A_list = list(map(int, input().split()))

for i in range(N-K):
    score1, score2 = (1,1)
    for j in range(K):
        score1 *= A_list[i+j]
        score2 *= A_list[i+j+1]
    if((score2 - score1) > 0):
        print('Yes')
    else:
        print('No')


# Optimized solution
# 入力
N,K = list(map(int, input().split()))
A_list = list(map(int, input().split()))

for i in range(N-K):
    if((A_list[i+K] - A_list[i]) > 0):
        print('Yes')
    else:
        print('No')
# Original solution
N,K = list(map(int,input().split()))
A = [int(i) for i in input().split()]
temp = 1
arr = []
for k in range(K-1):
    temp *= A[k]
for i in range(N-K+1):
    temp *= A[i+K-1]
    arr.append(temp)
    temp = temp // A[i]
for i in range(N-K):
    if arr[i] < arr[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(N-K):
    if A[i] < A[i+K]:
        print('Yes')
    else:
        print('No')
# Original solution
n,k=list(map(int,input().split()))
aa=list(map(int,input().split()))
value=1
for i in range(k):
  value*=aa[i]
for i in range(k,n):
  a=int(value*aa[i]/aa[i-k])
  if value<a:
    print("Yes")
  else:
    print("No")
  value=a

# Optimized solution
n,k=list(map(int,input().split()))
aa=list(map(int,input().split()))
for i in range(k,n):
  if aa[i]/aa[i-k]>1:
    print("Yes")
  else:
    print("No")
# Original solution
n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
dp=[0]*(n)
m=1
for i in range(n):
    if i>=k:
        m*=l[i]
        if m//dp[i-k] > cur:
            print("Yes")
        else:
            print("No")
        dp[i]=m
        cur=m//dp[i-k]

    else:
        m*=l[i]
        cur=m
        dp[i]=m



# 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
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    n, k = list(map(int, readline().split()))
    a = list(map(int, readline().split()))

    for i in range(k, n):
        if a[i - k] < a[i]:
            print("Yes")
        else:
            print("No")


if __name__ == '__main__':
    main()


# 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()))

times = 1
for i in range(K):
    times *= A[i]
# print(times)

for i in range(K , N):
    pre_times = times
    # print(i)
    # print(i)
    # print(A[i - K])
    # print(A[i])
    times = times // A[i - K ]
    times *= A[i]
    # print(times)
    if pre_times < times:
        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()))
a=input().split()
A=[int(b) for b in a]

numbers=[]

for n in range(N-K+1):
    suuji=A[n:n+K]
    answer=1
    for k in suuji:
        answer*=k
    numbers.append(answer)

for k in range(N-K):
    if numbers[k]<numbers[k+1]:
        print('Yes')
    else:
        print('No')
        

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

for k in range(N-K):
    if A[k]<A[k+K]:
        print('Yes')
    else:
        print('No')
# Original solution
from functools import reduce

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

before = 1

for a in ai[ 0 : k ]:
    before *= a

for i in range(n - k):
    after = before * ai[i + k] // ai[i]

    if before < after:
        print('Yes')

    else:
        print('No')

    before = after


# Optimized solution
from math import log2

n, k = list(map(int, input().split()))
ai   = list([log2(int(x)) for x in input().split()])

before = sum(ai[ 0 : k ])

for i in range(n - k):
    after = before + ai[i + k] - ai[i]

    if before < after:
        print('Yes')

    else:
        print('No')

    before = after
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

li = []
for i in range(n-k +1):
    tmp = a[i]
    for j in range(1, k):
        tmp *= a[i +j]
    li.append(tmp)

for i in range(len(li) -1):
    if (li[i] >= li[i+1]):
        print("No")
    else:
        print("Yes")

# 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[k+i]:
        print("No")
    else:
        print("Yes")
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

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

for j in range(K, N):
    H_next = H_now * A[j] / A[j-K]
    if H_next > H_now:
        print('Yes')
    else:
        print('No')


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

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

for i in range(0,n-k+1):
    for j in range(i,i+k):
        hyotei *= A[j]
    scores.append(hyotei)
    hyotei = 1
    
for i in range(n-k):
    if scores[i+1]>scores[i]:
        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(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()))
sc = [1]*(N-K+1)
for j in range(N-K+1):
  for i in range(K):
    sc[j] = sc[j]*A[j+i]
    
for j in range(N-K):
  if sc[j+1] > sc[j]:
    print('Yes')
  else:
    print('No')

# Optimized solution
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
    
for j in range(N-K):
  if A[j+K] > A[j]:
    print('Yes')
  else:
    print('No')
# Original solution
n, k = list(map(int, input().split()))
a = tuple(map(int, input().split()))
# 累積積を求める
acc = []
acc.append(a[0])
for v in a[1:]:
    acc.append(acc[-1]*v)
cand = []
cand.append(acc[k-1])
tmp = k
while tmp <= n-1:
    cand.append(acc[tmp]//acc[tmp-k])
    tmp += 1
for i in range(len(cand)-1):
    if cand[i] < cand[i+1]:
        print("Yes")
    else:
        print("No")

# Optimized solution
n, k = list(map(int, input().split()))
a = tuple(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()))
point = 1
for i in range(k):
  point = point*a[i]
#print(point)
t = 0
for j in range(k, n):
  point0 = point
  point = point*a[j]/a[t]
  t+=1
  if point > point0:
    print("Yes")
  else:
    print("No")

    

# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
#point = 1
t = 0
"""for i in range(t, n):
  point = point*a[i]"""
  
#print(point)
#t = 0
for j in range(k, n):
  #point0 = point
  #point = point*a[j]/a[t]
  if a[j] > a[t]:
    print("Yes")
  else:
    print("No")
  t+=1
# Original solution
from functools import reduce  # @lru_cache(None)
from operator import mul

n, k = (int(x) for x in input().split())
A = list(int(x) for x in input().split())

point = reduce(mul, A[:k])
for i in range(n-k):
    tmp = point
    point //= A[i]
    point *= A[k+i]
    if tmp >= point:
        print("No")
    else:
        print("Yes")

# Optimized solution
n, k = (int(x) for x in input().split())
A = list(int(x) for x in input().split())

for i in range(n - k):
    if A[i] >= A[k + i]:
        print("No")
    else:
        print("Yes")
# Original solution
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))
ans = 1
for i in range(K):
    ans = ans*A[i]
X = []
X.append(ans)
#print(X[0])
for i in range(K, N):
    ans = ans/A[i - K]
    ans = ans*A[i]
    X.append(ans)
    #print(X[i - K + 1])
    if X[i - K] < X[i - 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, 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()))

fact = [1] + [0] * N
for i,ai in enumerate(A, 1):
  fact[i] = fact[i-1] * ai

for i in range(1, N - K + 1):
  score_2 = fact[K + i] // fact[i]
  score_1 = fact[K + i - 1] // fact[i - 1]
  print(('Yes' if score_1 < score_2 else 'No'))

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

for i in range(N - K):
  score_2 = A[i+K]
  score_1 = A[i]
  print(('Yes' if score_1 < score_2 else 'No'))
# Original solution
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7 
#mod = 998244353
#from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10

def main():
	N, K = MAP()
	A = LIST()

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

	tmp2 = tmp
	for i in range(K, N):
		tmp =  tmp // A[i-K] * A[i]
		if tmp2 < tmp:
			print("Yes")
		else:
			print("No")
		tmp2 = tmp
if __name__ == '__main__':
	main()



# Optimized solution
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7 
#mod = 998244353
#from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10

def main():
	N, K = MAP()
	A = LIST()

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

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

if __name__ == "__main__":
    N, K = list(map(int, input().split()))
    A = list(map(int, input().split()))

    score = reduce(mul, A[:K])
    for i in range(K, len(A)):
        if A[i-K] < A[i]:
            print("Yes")
        else:
            print("No")


# Optimized solution
if __name__ == "__main__":
    N, K = list(map(int, input().split()))
    A = list(map(int, input().split()))

    for i in range(K, len(A)):
        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()))
val = 1
for i in range(0, k):
    val *= a[i]
    
for i in range(k, n):
    num = val*a[i]/a[i-k]
    if num > val:
        print('Yes')
    else:
        print('No')
    val = num


# 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
def resolve():
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))

    tmp = 1
    for i in a[:k]:
        tmp *= i

    for i in range(k, n):
        cost = tmp * a[i] // a[i-k]
        print(('Yes'  if cost > tmp else 'No'))
        tmp = cost

if __name__ == "__main__":
    resolve()


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

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

if __name__ == "__main__":
    resolve()
# Original solution
import itertools
import operator

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

pro = [1] + list(itertools.accumulate(A, func=operator.mul))

for i in range(K + 1, N + 1):
    if pro[i] * pro[i - K - 1] > pro[i - K] * (pro[i - 1]):
        print("Yes")
    else:
        print("No")


# Optimized solution
N, K = [int(x) for x in input().split(" ")]
A = [int(x) for x in 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()))
def kakeru(ary):
    result = 1
    for i in ary:
        result *= i
    return result

tmp =  kakeru(A[0:k])
point = tmp
for i in range(n-k):
    point = point * A[k+i] / A[i]
    if point > tmp:
        tmp = point
        print('Yes')
    else:
        tmp = point
        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')