CodeEff/ECCO huggingface dataset:
# Original solution
# import decimal
import time
time1 = time.time()

N, K = list(map(int, input().split()))
# N = 200000
# K = 50000
A_list = list(map(int, input().split()))
# A_list = [2 for i in range(N)]
Score_list = [1 for i in range(N+1)]

for i in range(K, N+1):
    if i == K:
        S = 1
        for j in range(i-K, i):
            S *= A_list[j]
        Score_list[i] = S
    else:
        Score_list[i] = int(Score_list[i-1] / A_list[i-1-K])
        Score_list[i] *= A_list[i-1]
    if i > K:
        if Score_list[i] > Score_list[i-1]:
            print("Yes")
        else:
            print("No")
    # print(Score_list)

# print(Score_list)
time2 = time.time()
# print(time2-time1)


# Optimized solution
# import decimal
import time
time1 = time.time()

N, K = list(map(int, input().split()))
# N = 200000
# K = 50000
A_list = list(map(int, input().split()))
# A_list = [2 for i in range(N)]
# Score_list = [1 for i in range(N+1)]

for i in range(K+1, N+1): #KからNの数字が入る
    # print(i-1)
    # print(i-2-K)
    if A_list[i-1] > A_list[i-1-K]:
        print("Yes")
    else:
        print("No")
    # if i == K:
    #     S = 1
    #     for j in range(i-K, i):
    #         S *= A_list[j]
    #     Score_list[i] = S
    # else:
    #     Score_list[i] = int(Score_list[i-1] / A_list[i-1-K])
    #     Score_list[i] *= A_list[i-1]
    # if i > K:
    #     if Score_list[i] > Score_list[i-1]:
    #         print("Yes")
    #     else:
    #         print("No")
    # # print(Score_list)

# print(Score_list)
time2 = time.time()
# print(time2-time1)
# Original solution
def main():
    n, k= list(map(int, input().split()))
    a = list(map(int, input().split()))
    
    pre = 1
    for b in a[0:k]:
        pre *= b
    now = pre
        
    for i in range(1, n-k+1):
        now = pre // a[i - 1] * a[k+ i -1]
        if pre < now:
            print('Yes')
        else:
            print('No')
        pre = now
    
    
if __name__ == '__main__':
    main()

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

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

for i in range(K + 1, N + 1):
    prev = prefix[i - 1] // prefix[i - K - 1]
    cur = prefix[i] // prefix[i - K]
    if cur > prev:
        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 = list(map(int, input().split()))
mul = [1]
for i in range(n):
    mul.append(mul[i]*a[i])

total = mul[-1]
pre = mul[k]
for i in range(k+1, n+1):
    now = mul[i] // mul[i-k]
    if pre < now:
        print('Yes')
    else:
        print('No')
    pre = now

# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = 1
for i in range(k):
    s *= a[i]

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

pre = s
for i in range(k, n):
    s *= a[i]
    s //= a[i-k]
    if pre < s:
        print('Yes')
    else:
        print('No')
    pre = s

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

rl = []

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

for m in range(n-k):
  if rl[m+1] > rl[m]:
    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 = list(map(int, input().split()))

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

# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
"""
point = 1
points = []

for i in range(n):
    point *= a[i]
    if i >= k - 1:
        points.append(point)
        if i >= k:
            if points[-1] > points[-2]:
                print("Yes")
            else:
                print("No")
        point //= a[i - k + 1]
"""
for i in range(n):
    if i >= k:
        if a[i] > a[i - k]:
            print("Yes")
        else:
            print("No")
# Original solution
def s(): return eval(input())
def i(): return int(eval(input()))
def S(): return input().split()
def I(): return list(map(int,input().split()))
def X(): return list(eval(input()))
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
count = 0
ans = "No"

N,K = I()
A = l()

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

for i in range(N-K):
    after = before / A[i] * A[K+i]
    if after > before:
        print("Yes")
    else:
        print("No")
    before = after





# Optimized solution
def s(): return eval(input())
def i(): return int(eval(input()))
def S(): return input().split()
def I(): return list(map(int,input().split()))
def X(): return list(eval(input()))
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
count = 0
ans = "No"

N,K = I()
A = l()


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

# prepare
mul = 1
for i in range(k):
    mul *= a[i]

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

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

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

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

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

	cur = new

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

nums = [0]*n
for i in range(n-k+1):
  nums[k+i-1] = sum(a[i:k+i])

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

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

nums = [0]*n
nums[k-1] = sum(a[:k])
for i in range(k,n):
  nums[i] = nums[i-1] + a[i] - a[i-k]

for i in range(k,n):
  if nums[i-1] < nums[i]: print("Yes")
  else: print("No")
# Original solution
def solve():
    n, k = list(map(int, input().split()))
    A = list(map(int, input().split()))
    tmp = 1
    for i in range(k):
        tmp *= A[i]

    for j in range(k + 1, n + 1):
        x = tmp * 1
        tmp //= A[j - k - 1]
        tmp *= A[j - 1]
        if tmp > x:
            print("Yes")
        else:
            print("No")


solve()


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

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


solve()
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
DP = [1] * (2 * 10 ** 6)
DP[0] = A[0]
for i in range(1, K):
    DP[i] = DP[i - 1] * A[i]


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


# Optimized solution
import sys
#import numpy as np
N, K = list(map(int, sys.stdin.readline().split()))
A = list(map(int, sys.stdin.readline().split()))
# DP = [1] * (2 * 10 ** 6)
# DP[K - 1] = np.prod(A[0:K])

for i in range(K, N):
    if A[i] / A[i - K] > 1:
        print("Yes")
    else:
        print("No")
# Original solution
import sys
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('No')
    else:
        print('Yes')

# 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 = input().split()
AList = list(map(int, input().split()))
CSList = []

i=int(K)
j=0
while j<=int(N)-int(K):
    BList=AList[j:i]
    if j==0:
        MAE=BList[0]
    elif MAE>=BList[-1]:
        print("No")
        MAE=BList[0]
    elif MAE<BList[-1]:
        print("Yes")
        MAE=BList[0]
    i+=1
    j+=1










# Optimized solution


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

A=str(K)
i=int(A)
j=0
while j<=N-K:
    #BList=AList[j:i]
    if j==0:
        MAE=AList[j]
    elif MAE>=AList[i-1]:
        print("No")
        MAE=AList[j]
    elif MAE<AList[i-1]:
        print("Yes")
        MAE=AList[j]
    i+=1
    j+=1
# Original solution
semester, K = list(map(int, input().split()))

score = input().split()

result1 = 1
result2 = 1

for i in range(semester - K + 1) :
    if i == 0 :
        for j in range(K) :
            result1 = result1 * int(score[K - 1 - j])
        continue
    
    result2 = result1 // int(score[K - K + i - 1]) * int(score[K - 1 + i])
    

    if result1 < result2 :
        print("Yes")
    else :
        print("No")

    result1 = result2
    result2 = 1




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

score = input().split()

for i in range(semester - K + 1) :
    if i == 0 :
        continue    

    if int(score[K - K + i - 1]) < int(score[K - 1 + i]) :
        print("Yes")
    else :
        print("No")
# Original solution
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n,k = LI()
a = LI()
tmp = 1
for i in range(k):
    tmp *= a[i]

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


# Optimized solution
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n,k = LI()
a = LI()
for i in range(k, n):
    if a[i] > a[i-k]:
        print('Yes')
    else:
        print('No')
# Original solution
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    N, K = list(map(int, readline().split()))
    A = list(map(int, readline().split()))
    X = 1
    for i in range(K):
        X *= A[i]
    B = [X]
    for i in range(K,N):
        tmp = B[-1] * A[i] // A[i-K]
        B.append(tmp)

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



if __name__ == '__main__':
    main()



# Optimized solution
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    N, K = list(map(int, readline().split()))
    A = list(map(int, readline().split()))
    for i in range(K,N):
        if A[i]<=A[i-K]:
            print('No')
        else:
            print('Yes')


if __name__ == '__main__':
    main()
# Original solution
N,K = list(map(int,input().split()))
gakki = list(map(int,input().split()))

temp1 = gakki[0]
for i in range(1,K):
    temp1 *= gakki[i]

for i in range(N - K):
    temp2 = int(temp1 / gakki[i] * gakki[K + i])
    if temp1 < temp2:
        print("Yes")
    else:
        print("No")
    temp1 = temp2
    


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


for i in range(N - K):
    temp1 = gakki[i]
    temp2 = gakki[K + i]
    if temp1 < temp2:
        print("Yes")
    else:
        print("No")
    temp1 = temp2
# Original solution
N, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
i_list = [0] * (N+1)
cnt = 0

for k in range(K, N+1):
    A_sum = A[cnt]
    for i in range(cnt, K+cnt-1):
        if A[i+1] == 0:
            A_sum = 0
            break
        else:
            A_sum = A_sum * A[i+1]
    i_list[k] = A_sum
    A_sum = 0
    cnt = cnt + 1

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

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

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


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

scores = []

s = 0
score = 1
for i in range(k):
    score *= a[i]

scores.append(score)
for i in range(k,n):
    score = score // a[s] * a[i]
    s += 1
    scores.append(score)

#print(scores)
for i in range(len(scores)-1):
    if scores[i+1] > scores[i]:
        print('Yes')
    else:
        print('No')

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

f = 0
for _ in range(n-k):
    if a[f] < a[f+k]:
        print('Yes')
    else:
        print('No')
    f += 1
# Original solution
#n=int(input())
n,k=list(map(int,input().split()))
al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
def f(l):
    res=1
    for li in l:
        res=res*li
    return res
sc=[]
alr=0
for i in range(k-1,n):
    
    if alr==0:
        score=f(al[i-k+1:i+1])
        alr=1
    else:
        first=al[i-k]
        last=al[i]
        score=(score//first)*last
    sc.append(score)
for i in range(n-k):
    if sc[i+1]>sc[i]:
        print('Yes')
    else:
        print('No')

# Optimized solution
#n=int(input())
n,k=list(map(int,input().split()))
al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
def f(l):
    res=1
    for li in l:
        res=res*li
    return res
sc=[]
alr=0
for i in range(k-1,n):
    if i==k-1:
        #score=f(al[i-k+1:i+1])
        first=al[i-k+1]
        alr=1
    else:
        #first=al[i-k]
        last=al[i]
        if last>first :
            print('Yes')
        else:
            print('No')
        first=al[i-k+1]
# Original solution
#n=int(input())
n,k=list(map(int,input().split()))
al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
def f(l):
    res=1
    for li in l:
        res=res*li
    return res
sc=[]
alr=0
for i in range(k-1,n):
    if i==k-1:
        #score=f(al[i-k+1:i+1])
        first=al[i-k+1]
        alr=1
    else:
        #first=al[i-k]
        last=al[i]
        if last>first :
            print('Yes')
        else:
            print('No')
        first=al[i-k+1]


# Optimized solution
#n=int(input())
n,k=list(map(int,input().split()))
al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

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

f = 0
d = 1
e = 1
for i in range(n-k):
    for j in range(k):
        d *= a[i+j]
        e *= a[i+j+1]

    if d < e:
        print("Yes")
        d,e = 1,1
    else:
        print("No")
        d,e = 1,1

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

f = 0
d = 1
e = 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()))
ma = min(a)

a = list([x - ma + 1 for x in a])

befscore = 1
score = 1
f = True
for i in range(n):
    score = score * a[i]

    if i >= k:
        score = int(score / a[i - k])
        if befscore >= score:
            print("No")
        else:
            print("Yes")

    befscore = score


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

a = list([x - ma for x in a])

befscore = 1
score = 1
f = True
for i in range(n):
    score = score + a[i]

    if i >= k:
        score = int(score - a[i - k])
        if befscore >= score:
            print("No")
        else:
            print("Yes")

    befscore = score
# Original solution
n=list(map(int,input().strip().split()))
m=list(map(int,input().strip().split()))
a=[]
c=0
x=1
for i in range(0,n[1]):
  x*=m[i]
a.append(x)
#print(a)
l=0
k=n[1]
for i in range(0,n[0]-n[1]):
  x//=m[l]
  x*=m[k]
  a.append(x)
  #print(a)
  l+=1
  k+=1
for i in range(0,len(a)-1):
    if(a[i]<a[i+1]):
        print("Yes")
    else:
        print("No")

# Optimized solution
n=list(map(int,input().strip().split()))
m=list(map(int,input().strip().split()))
for i in range(n[0]-n[1]):
    if(m[i+n[1]]>m[i]):
        print("Yes")
    else:
        print("No")
# Original solution
N, K = input().split()
N = int(N)
K = int(K)
a = input().split()
A = [int(u) for u in a]
Prod = 1
G = []
for i in range(0, N):
	Prod *= A[i]
	if i >= K:
		Prod = Prod // A[i - K]
	if i >= K - 1:
		G.append(Prod)

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

# Optimized solution
N, K = input().split()
N = int(N)
K = int(K)
a = input().split()
A = [int(u) for u in a]
for i in range(0, 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()))

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

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



# 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
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import itertools
def S(): return eval(input())
def I(): return int(eval(input()))
def MS(): return list(map(str,input().split()))
def MI(): return list(map(int,input().split()))
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in eval(input())]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

N,K = MI()

A = LI()

multi = {}

start = 1
for k in range(0,K):
    start = start * A[k]

for j in range(K, N+1):
    if j == K:
        multi[j] = start
        continue
    start = start // A[j-K-1] * A[j-1]
    multi[j] = start

    if j-1 in multi:
        if multi[j] > multi[j-1]:
            print("Yes")
        else:
            print("No")



# Optimized solution
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import itertools
def S(): return eval(input())
def I(): return int(eval(input()))
def MS(): return list(map(str,input().split()))
def MI(): return list(map(int,input().split()))
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in eval(input())]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

N,K = MI()

A = LI()

for j in range(K, N+1):
    if j == K:
        continue
    if A[j-K-1] < A[j-1]:
        print("Yes")
    else:
        print("No")
# Original solution
import functools
import operator
prod = functools.partial(functools.reduce, operator.mul)

listS = []

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

for i in range(0,N-K):
    if prod(A[i:K+i]) < prod(A[i+1:K+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(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()))

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


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

score = 1
for i in range(K,N):
  if A[i] > A[i-K]:
    print('Yes')
  else:
    print('No')
# Original solution
import bisect,collections,copy,heapq,itertools,math,string
import sys
from collections import deque
def S(): return sys.stdin.readline().rstrip()
def M(): return list(map(int,sys.stdin.readline().rstrip().split()))
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())
n, k = M()
A = deque(LI())
ans = deque()
for i in range(n-1, k-1, -1):
    if A[i] > A[i-k]:
        ans.appendleft('Yes')
    else:
        ans.appendleft('No')
for s in ans:
    print(s)

# Optimized solution
import bisect,collections,copy,heapq,itertools,math,string
import sys
from collections import deque
def S(): return sys.stdin.readline().rstrip()
def M(): return list(map(int,sys.stdin.readline().rstrip().split()))
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())
n, k = M()
A = deque(LI())
ans = deque()
for i in range(k, n):
    if A[i] > A[i-k]:
        print('Yes')
    else:
        print('No')