CodeEff/ECCO huggingface dataset:
# Original solution
tmp = (input().split(' '))
n = int(tmp[0])
k = int(tmp[1])
tmp = input().split(' ')
grades = []
for i in range(len(tmp)):
  grades.append(int(tmp[i]))
  
curr_res = grades[0]
prev_res = grades[0]

for i in range(1,k):
  curr_res = curr_res * grades[i]
  
j = k
while j < n:
  prev_res = curr_res
  curr_res = curr_res/grades[j-k]
  curr_res = curr_res*grades[j]
  if curr_res > prev_res:
    print('Yes')
  else:
    print('No')
  j+=1
  

# Optimized solution
tmp = (input().split(' '))
n = int(tmp[0])
k = int(tmp[1])
tmp = input().split(' ')
map_tmp = list(map(int,tmp))
grades = list(map_tmp)
j = k
while j < n:
  curr_res = grades[j]
  prev_res = grades[j-k]
  if curr_res > prev_res:
    print('Yes')
  else:
    print('No')
  
  j+=1
# Original solution
def listseki(A,start,end):
    ans=1
    for i in range(start,end+1):
        ans*=A[i]
    return ans
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
oldseki=listseki(A,0,K-1)
for i in range(1,N-K+1):
    nowseki=listseki(A,i,i+K-1)
    if nowseki>oldseki:
        print("Yes")
    else:
        print("No")
    oldseki=nowseki

# Optimized solution
def listseki(A,start,end):
    ans=A[end]/A[start-1]
    return ans
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(1,N-K+1):
    nowseki=listseki(A,i,i+K-1)
    if nowseki>1:
        print("Yes")
    else:
        print("No")
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
syaku=1
for i in range(k):
  syaku*=a[i]
now=syaku
for i in range(k,len(a)):
  pre=now
  now=now*a[i]//a[i-k]
  if pre<now:
    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):
#  syaku*=a[i]
#now=syaku
for i in range(k,len(a)):
  #pre=now
  #now=now*a[i]//a[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()))
V=list()
for i in range(N-K+1):
  a=1
  for j in range(K):
    a=a*A[(i+j)]
  V.append(a)
for i in range((N-K)):
  if V[i]<V[i+1]:
    print("Yes")
  else:
    print("No")

# Optimized solution
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
V=list()
for i in range(N-K):
  if A[i]<A[K+i]:
    print("Yes")
  else:
    print("No")
# Original solution
def prod(X):
    val = 1
    for x in X:
        val = val * x
    return val

N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
G = [prod(A[:K])]
for i in range(K, N):
    val = G[-1] // A[i - K] * A[i]
    G.append(val)
# print(G)

for i in range(1, len(G)):
    print(('Yes' if G[i] > G[i - 1] else 'No'))

# Optimized solution
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'))
# Original solution
n, k = list(map(int, input().split()))
a_list = list(map(int, input().split()))

score = [1] * (n - k + 1)

for i in range(k):
    score[0] *= a_list[i]

for i in range(1, n-k+1):
    score[i] = (score[i-1] / a_list[i-1]) * a_list[k+i-1]

for i in range(len(score)-1):
    if score[i+1] - score[i] > 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] < a_list[k+i]:
        print("Yes")
    else:
        print("No")
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(n-k):
  c = sum(a[i:i+k])
  d = sum(a[i+1:i+k+1])
  if c < d:
    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_l = list(map(int, input().split()))

i = 0
score = 1
b_score = None
while i < n:
    score *= a_l[i]
    if i > k-1:
        score = int(score/a_l[i-k])
    if b_score is not None:
        if score > b_score:
            print('Yes')
        else:
            print('No')
    if i >= k-1:
        b_score = score
    i+=1

# Optimized solution
n, k = list(map(int, input().split()))
a_l = list(map(int, input().split()))
i = 0
while i < n:
    if i >= k:
        if a_l[i] > a_l[i-k]:
            print('Yes')
        else:
            print('No')
    i+=1
# Original solution
n, k = list(map(int,input().split()))
a_list = list(map(int,input().split()))

dp = [1] * (n-k+1)

for i in range(0,k):
    dp[0] = dp[0] * a_list[i]

for j in range(1, n-k+1):
    dp[j] = dp[j-1] * a_list[k+j-1] / a_list[j-1]

for l in range(len(dp)-1):
    if dp[l] < dp[l+1]:
        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(0, n-k):
    if a_list[i] < a_list[k+i]:
        print('Yes')
    else:
        print('No')
# Original solution
def main():
    N, K = list(map(int, input().split()))
    l = list(map(int, input().split()))
    
    for i in range(N - K):
        p = 0
        n = 0
        for j in range(K):
            p = p + l[j+i]
            n = n + l[j+i+1]
        if p < n:
            print('Yes')
        else:
            print('No') 
main()



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

S = []
cnt = 0
for i in range(K-1,N):
    s = 1
    for j in range(i,i-K,-1):
        s *= A[j]
    S.append(s)
    
    if cnt == 0:
        cnt += 1
        continue
    print(("Yes" if S[cnt-1]<S[cnt] else "No"))
    cnt += 1

# Optimized solution
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] / A[i-K] > 1 :
        print("Yes")

    else :
        print("No")
# Original solution
from sys import stdin
input = stdin.buffer.readline

n, k = list(map(int, input().split()))
*a, = list(map(int, input().split()))
p = 1
for i in range(k):
	p *= a[i]
for i in range(k, n):
	q = p * a[i] // a[i - k]
	if q > p:
		print('Yes')
	else:
		print('No')
	p = q


# Optimized solution
from sys import stdin
input = stdin.buffer.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
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
point=[1]*N
for i in range(K-1,N):
  for j in range(K):
    point[i]*=A[i-j]
for i in range(K-1,N-1):
  if(point[i]>=point[i+1]):
    print("No")
  else:
    print("Yes")

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

s = [1] * len(a)
s[0] = a[0]
for i in range(n - 1):
    s[i + 1] = s[i] * a[i + 1]
    
num = [0] * (len(a) - k + 1)
num[0] = s[k - 1]
for i in range(len(a) - k):
    num[i + 1] = s[i + k] // s[i]
    
for i in range(len(a) - k):
    if num[i] < num[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(len(a) - k):
    if a[i] < a[i + k]:
        print('Yes')
    else:
        print('No')
# Original solution
import functools
import operator

n = functools.partial(functools.reduce, operator.mul)
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
# print(n(A))
S = [0] * K
s = 0
for i in range(K,len(A)+ 1):
    # print(i)
    # S.append(n(A[(i-1)-(K-1):i]))
    # print(n(A[(i-1)-(K-1):i]))
    if i == K:
        s = n(A[(i-1)-(K-1):i])
        continue
    else:
        if s < n(A[(i-1)-(K-1):i]):
            print("Yes")
            s = n(A[(i-1)-(K-1):i])
        else:
            print("No")
            s = n(A[(i-1)-(K-1):i])

        



# Optimized solution
import functools
import operator

n = functools.partial(functools.reduce, operator.mul)
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
# print(n(A))
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()))
Ai = list(map(int, input().split()))
results= []

for i in range(0,N-K + 1):
    result = 1
    for j in range(i,K + i):
        result = result * Ai[j]
    results.append(result)

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


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

for i in range(0,N-K):

    if(Ai[i] < Ai[i+K]):
        print("Yes")
    else:
        print("No")
# Original solution
n, k = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))

score: list = []
for i in range(k - 1, n):
    tmp_score = 1
    for j in range(k):
        tmp_score *= a[i - j]
    score.append(tmp_score)

for i in range(len(score) - 1):
    # print(score[i], score[i + 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
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
from collections import defaultdict
sys.setrecursionlimit(10**7)
import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque


def run():
    N, K, *A = list(map(int, read().split()))
    A = [-1] + A
    INF = 1 << 50
    X = [INF, 1, 1]
    for i, a in enumerate(A[1:], 1):
        pre = X[1]
        if i <= K:
            if a == 0:
                X[0] = i
                X[1] = 0
                X[2] = 1
                continue

            X[1] *= a
            X[2] *= a
        if i > K:
            if a == 0:
                X[0] = i
                X[1] = 0
                X[2] = 1
                continue
            if i - K == X[0]:
                X[0] = INF
                X[1] = X[2]
            elif A[i-K] == 0:
                pass
            else:
                X[1] /= A[i-K]
            X[1] *= a
            X[2] *= a
            if pre < X[1]:
                print('Yes')
            else:
                print('No')


if __name__ == "__main__":
    run()

# Optimized solution
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
from collections import defaultdict
sys.setrecursionlimit(10**7)
import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque


def run():
    N, K, *A = list(map(int, read().split()))
    A = [-1] + A
    INF = 1 << 50
    X = [INF, 1, 1]
    for i in range(K, N):
        if A[i+1] > A[i-K+1]:
            print('Yes')
        else:
            print('No')




if __name__ == "__main__":
    run()
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
AA = []
for i in range(N - K + 1):
  f = 1
  for j in range(i, i + K):
    f *= A[j]
  AA.append(f)
  
for i in range(len(AA) - 1):
  if AA[i] < AA[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
def main():
    N, K = input_ints()
    A = input_int_list_in_line()

    hyouten = 1

    for i in range(K):
        hyouten *= A[i]
    
    for i in range(N-K):
        new_hyouten = hyouten / A[i] * A[i+K]

        if hyouten < new_hyouten:
            print('Yes')
        else:
            print('No')
        
        hyouten = new_hyouten



def input_ints():
    line_list = input().split()

    if len(line_list) == 1:
        return int(line_list[0])
    else:
        return list(map(int, line_list))


def input_int_list_in_line():
    return list(map(int, input().split()))


def input_int_tuple_list(n: int):
    return [tuple(map(int, input().split())) for _ in range(n)]


main()


# Optimized solution
def main():
    N, K = input_ints()
    A = input_int_list_in_line()

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


def input_ints():
    line_list = input().split()

    if len(line_list) == 1:
        return int(line_list[0])
    else:
        return list(map(int, line_list))


def input_int_list_in_line():
    return list(map(int, input().split()))


def input_int_tuple_list(n: int):
    return [tuple(map(int, input().split())) for _ in range(n)]


main()
# 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(n-k):
    prev=tmp
    tmp=int(tmp/a[i]*a[i+k])
    #print(tmp)
    if tmp>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(n-k):

    if a[i]<a[i+k]:
        print("Yes")
    else:
        print("No")
# Original solution
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

N, K = LI()
A = LI()

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

# Optimized solution
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

# N, K = LI()
# A = LI()

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


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


# Optimized solution
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'))
# Original solution
# coding: utf-8


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

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

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


main()


# Optimized solution
# coding: utf-8


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

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


main()
# Original solution
n, k = list(map(int,input().split()))
A = list(map(int,input().split()))

res=[0]*(n-k+1)
for i in range(n-k+1):
    x = 1
    for j in A[i:k+i]:
        x *= j
    res[i]=x
for i in range(1,len(res)):
    if res[i] > res[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
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

result = 1

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

for i in range(k, n):
    before_result = result
    result /= a[i - k]
    result *= a[i]
    if before_result < result:
        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()))

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

for j in range(len(b) - 1):
    b[j + 1] = (b[j + 1] + b[j]) // a[j] * a[j + k]

for l in range(len(b)-1):
    if b[l] < b[l + 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("No")
    else:
        print("Yes")
# Original solution
n, k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
a.reverse()

lists = []
answer = a[0]
for i in range(1, k):
    answer = answer * a[i]
lists.append(answer)

for i in range(n - k):
    answer = answer / a[i] * a[i + k]
    lists.append(answer)

lists.reverse()

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


# Optimized solution
n, k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
a.reverse()
lists = []

for i in range(n - k):
    if a[i] <= a[i + k]:
        lists.append(0)
    else:
        lists.append(1)
lists.reverse()

for i in range(n - k):
    if lists[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()))

before = reduce(lambda a, b: a * b, A[:K])
for i in range(0, N - K):
    temp = before // A[i] * A[K + i]
    if temp > before:
        print("Yes")
    else:
        print("No")
    before = temp

# 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[K + i]:
        print("Yes")
    else:
        print("No")
# Original solution
import math
import collections
import fractions
import itertools
import functools
import operator

def solve():
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))
    ruiseki = [1]
    ruiseki2 = []
    for i in range(1, n+1):
        ruiseki.append(a[i-1]*ruiseki[i-1])
    for i in range(k-1, n):
        ruiseki2.append(ruiseki[i+1]//ruiseki[i-k+1])
    for i in range(n-k):
        if ruiseki2[i] < ruiseki2[i+1]:
            print("Yes")
        else:
            print("No")
    return 0

if __name__ == "__main__":
    solve()


# Optimized solution
import math
import collections
import fractions
import itertools
import functools
import operator

def solve():
    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")
    return 0

if __name__ == "__main__":
    solve()
# Original solution
n, k = list(map(int, input().split()))
dat = list(map(int, input().split()))

prev = 1
for i in range(k):
    prev *= dat[i]

for i in range(n-k):
    new = dat[k + i]
    nukeru = dat[i]
    newval = prev // nukeru * new
    if newval > prev:
        print("Yes")
    else:
        print("No")
    prev = newval

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

prev = dat[0]

for i in range(n-k):
    new = dat[k + i]
    nukeru = dat[i]
    if new > nukeru:
        print("Yes")
    else:
        print("No")
    prev = new
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
seiseki = []

for i in range(N - K + 1):
  num = 1
  for j in range(K):
    num *= A[i + j]
  seiseki.append(num)
  if i > 0:
    if seiseki[-2] < seiseki[-1]:
      print("Yes")
    else:
      print("No")

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

for i in range(N - K):
  if A[i] < A[i + K]:
    print("Yes")
  else:
    print("No")
# Original solution
import math
import collections
import fractions
import itertools
import functools
import operator

def solve():
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))
    ruiseki = [1]
    for i in range(1, n+1):
        ruiseki.append(a[i-1]*ruiseki[i-1])
    for i in range(k-1, n-1):
        if ruiseki[i+1]//ruiseki[i-k+1] >= ruiseki[i+2]//ruiseki[i+2-k]:
            print("No")
        else:
            print("Yes")
    return 0

if __name__ == "__main__":
    solve()


# Optimized solution
import math
import collections
import fractions
import itertools
import functools
import operator

def solve():
    n, k = 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 print("No")
    return 0

if __name__ == "__main__":
    solve()
# Original solution
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,k = list(map(int,readline().split()))
a = list(map(int,readline().split()))
c = 1
for i in range(k):
  c *= a[i]
  
for i in range(n-k):
  chk = c*a[k+i]//a[i]
  if chk > c:
    print('Yes')
  else:
    print('No')

# Optimized solution
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,k = list(map(int,readline().split()))
a = list(map(int,readline().split()))
for i in range(n-k):
  chk = a[k+i]
  c = a[i]
  if chk > c:
    print('Yes')
  else:
    print('No')
# Original solution
# C - Marks
from functools import reduce
from operator import mul


def main():
    N, K, *A = list(map(int, open(0).read().split()))
    top_idx, prev_score = 0, reduce(mul, A[:K])
    res = []
    for top, cur in zip(A, A[K:]):
        cur_score = prev_score // top * cur
        res.append("Yes" if cur_score > prev_score else "No")
        prev_score = cur_score
    print(("\n".join(res)))


if __name__ == "__main__":
    main()


# Optimized solution
# C - Marks
def main():
    N, K, *A = list(map(int, open(0).read().split()))
    res = ["Yes" if tail > top else "No" for top, tail in zip(A, A[K:])]
    print(("\n".join(res)))


if __name__ == "__main__":
    main()
# Original solution
N, K = [int(s) for s in input().split()]
A = [int(s) for s in input().split()]

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

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

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