CodeEff/ECCO huggingface dataset:
# Original solution
from operator import mul
from functools import reduce
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
before = reduce(mul, A[:k])

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

# Optimized solution
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
before = sum(A[:k])

for i in range(n-k):
    tmp = before + A[i+k] - A[i]
    if tmp > before:
        print("Yes")
    else:
        print("No")
    before = tmp
# 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]

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


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

now = a[0]
idx = 0
gabbege = a[idx]
length = 1
for i in range(1, n):
    if length < k:
        length += 1
        now *= a[i]
    else:
        if now < now // gabbege * a[i]:
            print("Yes")
        else:
            print("No")
        now = now // gabbege * a[i]
        idx += 1
        gabbege = a[idx]

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

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

ans = []
g = 0
for i in range(N-K+1):
  k = 1
  for s in range(K):
    k *= a[s+i]%10**9
  ans.append(k)
  if len(ans)>1:
    if ans[0]<ans[1]:
      print("Yes")
    else:
      print("No")
    del ans[0]


# 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,*a=list(map(int,open(0).read().split()))
multiple=1
for i in range(k):
    multiple*=a[i]
for j in range(n-k):
    if a[j+k]>a[j]:
        print('Yes')
    else:
        print('No')
    multiple=multiple*a[j+k]/a[j]

# Optimized solution
n,k,*a=list(map(int,open(0).read().split()))
multiple=1
#for i in range(k):
#    multiple*=a[i]
for j in range(n-k):
    if a[j+k]>a[j]:
        print('Yes')
    else:
        print('No')
#    multiple=multiple*a[j+k]/a[j]
# Original solution
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
import random
from collections import deque
from decimal import *
import queue

input = sys.stdin.readline

def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

def main():
	N,K = inputMap()
	A = inputList()

	ans = 1
	ans_old = 1
	mae = 0
	for i,val in enumerate(A):
		if i < K:
			ans_old *= val
			continue

		mae = A[i-K]
		ans = ans_old
		ans = ans / mae * val
		if ans > ans_old:
			print("Yes")
		else:
			print("No")
		ans_old = ans


#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
	main()


# Optimized solution
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
import random
from collections import deque
from decimal import *
import queue

input = sys.stdin.readline

def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

def main():
	N,K = inputMap()
	A = inputList()

	ans = 1
	ans_old = 1
	mae = 0
	for i,val in enumerate(A):
		if i < K:
			continue
		tmp = A[i-K]
		if val > tmp:
			print("Yes")
		else:
			print("No")



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

evaluations = []
for n in range(N):
    if n < K-1:
        evaluations.append(0)
    else:
        evaluation = 1
        for i in range(K):
            evaluation *= A[n-i]
        evaluations.append(evaluation)
# print(evaluations)

for n in range(K, N):
    print(('Yes' if evaluations[n] > evaluations[n-1] else 'No'))


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

for n in range(K, N):
    print(('Yes' if A[n] > A[n-K] else 'No'))
# Original solution
N,K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
ans = [0]*(N-K+1)
score = 1
for i in range(K):
    score *= A[i]
for i in range(K, N):
    ans[i - K] = score
    score //= A[i - K]
    score *= A[i]
ans[-1] = score
print(("\n".join(["Yes" if ans[i] > ans[i-1] else "No" for i in range(1,len(ans))])))

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

S = [1]
for i in range(0, N):
 S.append(S[i] * A[i])

count = 0
prev = -1
for i in range(K, N+1):
  current = S[i]//S[count]
  if prev != -1:
    if current > prev:
      print("Yes")
    else:
      print("No")
  prev = current
  count += 1 



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

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

for i in range(K, N):
  ans = prev
  ans //= A[count]
  ans *= A[i]
  if ans > prev:
    print("Yes")
  else:
    print("No")
  prev = ans
  count += 1
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

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

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



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

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

hyouten = [1]*n
hyouten[0] = a[0]
for i in range(1, n):
    hyouten[i] = hyouten[i-1]*a[i]
#print(hyouten)
for i in range(k+1, n+1):
    hyouten[i-1] //= hyouten[i-k-1]
    if hyouten[i-1] > hyouten[i-2]:
        print("Yes")
    else:
        print("No")
#print(hyouten)

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


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

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

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

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


resolve()

# Optimized solution
import math

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

    # dp=[1]*202020
    # for i in range(K):
    #     dp[K]*=A[i]

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


resolve()
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
count=0
ans=None
d=0
for i in range(n-k+1):
  if d==0:
    d=1
    gakki=1
    for j in range(count,k+count):
      gakki*=a[j]
      
  else:
    gakki/=a[count]
    gakki*=a[k+count]
    count+=1
  
  if ans is None:
    ans=gakki
  else:
    if ans<gakki:
      print('Yes')
      ans=gakki
    else:
      print("No")
      ans=gakki

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

# Optimized solution
N,K = list(map(int,input().split(' ')))
A = list(map(int,input().split(' ')))
cnt = 0
for k in range(K,N):
    if A[k] > A[cnt]:
        print("Yes")
    else:
        print("No")
    cnt += 1
# Original solution
def main():
    N, K = list(map(int, input().split()))
    A = [1] + list(map(int, input().split()))
    for i in range(2, N+1):
        A[i] *= A[i-1]
    for i in range(K+1, N+1):
        cur = A[i]//A[i-K]
        prev = A[i-1]//A[i-K-1]
        if cur > prev:
            print("Yes")
        else:
            print("No")


if __name__ == "__main__":
    main()


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


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

P_before = 1
for k in range(K):
    P_before = P_before*A[k]
    
P_before


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

# Optimized solution
#C
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()))
score = list(map(int, input().split()))

mv_scores = []
for i in range(k, n+1):
    tmp_score = 1
    for s in score[i-k:i]:
        tmp_score *= s
    mv_scores.append(tmp_score)

for j in range(1, len(mv_scores)):
    if mv_scores[j] - mv_scores[j-1] > 0:
        print("Yes")
    else:
        print("No")

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

for i in range(k, n):
    if score[i-k] < score[i]:
        print("Yes")
    else:
        print("No")
# Original solution
from functools import  reduce
n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
x=reduce(lambda x,y: x*y,l[:k])
temp=[x]
for i in range(k,len(l)):
	if l[i]<=l[i-k]:
		print('No')
	else:
		print('Yes')
		

# Optimized solution
n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
for i in range(k,len(l)):
	if l[i]<=l[i-k]:
		print('No')
	else:
		print('Yes')
# Original solution
N, K = list(map(int, input().split()))
list_A = list(map(int, input().split()))
results = []
for i in range(N - K + 1):
    result = 1
    for j in range(K):
        result *= list_A[j + i]
    results.append(result)

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

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

for i in range(N - K):
    if list_A[i] < list_A[i + K]:
        print("Yes")
    else:
        print("No")
# Original solution
import sys
input = sys.stdin.readline

def main():
    n,k = list(map(int, input().split()))
    A = list(map(int, input().split()))
    
    score = 1
    for a in A[:k]:
        score*=a
    
    for i in range(k,n):
        tmp_score = score//A[i-k] * A[i]
        if tmp_score > score:
            print("Yes")
        else:
            print('No')
        score = tmp_score
main()

# Optimized solution
import sys
input = sys.stdin.readline

def main():
    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')
main()
# Original solution
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))

b = 1
for i in A[0:K]:
    b *= i
for i in range(N-K):
    a = b/A[i]*A[i+K]
    if b < a :
        print("Yes")
    else:
        print("No")
    b = a


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

result = []
for i in range(K, N):
    if A[i] > A[i - K]:
        result.append('Yes')
    else:
        result.append('No')
print(*result, sep='\n')
# Original solution
from functools import reduce
from operator import mul

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

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

# 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
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify

import itertools, bisect
import math, fractions
import sys, copy

def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def S(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]

alphabets = "abcdefghijklmnopqrstuvwxyz"

sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007

def main():
    N, K = LI()
    A = LI()
    cum = [1] * (N + 1)
    val = []

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

    for i in range(K, N+1):
        val.append(cum[i] // cum[i - K])

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


if __name__ == '__main__':
    main()

# Optimized solution
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify

import itertools, bisect
import math, fractions
import sys, copy

def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def S(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]

alphabets = "abcdefghijklmnopqrstuvwxyz"

sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007

def main():
    N, K = LI()
    A = LI()

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


if __name__ == '__main__':
    main()
# Original solution
def main():
    n, k = [int(e) for e in input().split()]
    A = [int(e) for e in input().split()]

    s = A[0]
    for i in range(1, k):
        s *= A[i]

    prev = s
    for i in range(n - k):
        s //= A[i]
        s *= A[k + i]

        if prev < s:
            print('Yes')
        else:
            print('No')

        prev = s


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    n, k = [int(e) for e in input().split()]
    A = [int(e) for e in input().split()]

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


if __name__ == '__main__':
    main()
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
l=[0]*(n+1)
l[0]=1
l[1]=a[0]
for i in range(2,n+1):
  l[i]=l[i-1]*a[i-1]
#print(l)
grade=[0]*(n-k+1)
for i in range(n-k+1):
  grade[i]=l[i+k]//l[i]
#print(grade)
for i in range(n-k):
  if grade[i]<grade[i+1]:
    print("Yes")
  else:
    print("No")

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

from collections import Counter, defaultdict, deque


def solve(N, K, A):
    window = deque()
    val = 1
    grades = []
    for x in A:
        window.append(x)
        val *= x

        if len(window) > K:
            val //= window.popleft()
        if len(window) == K:
            grades.append(val)
    ans = []
    for x, y in zip(grades, grades[1:]):
        if x < y:
            ans.append("Yes")
        else:
            ans.append("No")

    return "\n".join(ans)


if __name__ == "__main__":
    input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
    N, K = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]
    ans = solve(N, K, A)
    print(ans)



# Optimized solution
import io
import os

from collections import Counter, defaultdict, deque


def solve(N, K, A):
    window = deque()
    ans = []
    for x in A:
        window.append(x)

        if len(window) > K:
            if window.popleft() < x:
                ans.append("Yes")
            else:
                ans.append("No")
    return "\n".join(ans)


if __name__ == "__main__":
    input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
    N, K = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]
    ans = solve(N, K, A)
    print(ans)
# Original solution
from operator import mul
from functools import reduce

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

hyouten_count = N - K

result_list = []

result = 1

for i in range(K-1, N):
    # print(num)
    # result = 1
    num = i-K+1
    result = reduce(mul, A[num:i+1])
    # for j in range(K):
    #     result = result * A[i - j]
    # print(result)
    # print(result)
    result_list.append(result)
    result = 1


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

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


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

    R = [1]
    for i in range(n):
        R.append(R[-1] * A[i])

    prev = R[k]
    for i in range(k + 1, n + 1):
        now = R[i] // R[i - k]
        print(("Yes" if prev < now else "No"))
        prev = now


if __name__ == '__main__':
    resolve()


# Optimized solution
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


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

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


if __name__ == '__main__':
    resolve()
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = ['No' for i in range(n - k)]

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

for i in range(1, n - k + 1):
    cur = (pre // a[i - 1]) * a[i + k-1]
    if cur > pre:
        ans[i - 1] = 'Yes'

    pre = cur


for i in ans:
    print(i)


# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = ['No' for i in range(n - k)]


for i in range(n - k):
    if a[i] < a[i + k]:
        ans[i] = 'Yes'


for i in ans:
    print(i)
# Original solution
n ,k = list(map(int, input().split()))
lis = list(map(int, input().split()))

t = sum(lis[:k])

 
for i in range(k, n):
    a = sum(lis[i-k+1:i+1])
    
    if a > t:
        print('Yes')
    else:
        print('No')
    
    t = a
    a = 0

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

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


for i in range(k,n+1):
    for j in range(k):
        score*=a[i-k+j]
    s.append(score)
    score=1
#print(s)

for i in range(n-k):
    if (s[i+1]-s[i])>0:
        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()))
ans = [0] * (N)
temp = 1
for i in range(K):
    temp *= A[i]
ans[K - 1] = temp
for i in range(K, N):
    ans[i] = ans[i - 1] * A[i] // A[i - K]
    if ans[i] > ans[i - 1]:
        print('Yes')
    else:
        print('No')


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