CodeEff/ECCO huggingface dataset:
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))


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

for i in range(K, N):
    pre = p
    p = (p // A[i - K]) * A[i]

    if (pre < p):
        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()))
X = []
ans = 1
for i in range(K):
    ans = ans*A[i]
X.append(ans)

for i in range(K+1,N+1):
    ans = (ans//A[i-1-K])*A[i-1]
    X.append(ans)
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(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(' ')))
score = 1
for i in range(k):
    score *= a[i]
for i in range(k-1, n-1):
    if int(score) < int(score*a[i+1]/a[i-k+1]):
        print('Yes')
    else:
        print('No')
    score = score*a[i+1]/a[i-k+1]

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

num = 1
cnt = 0
lst = []
for i in range(N):
    if (i < K):
        num *= A[i]
    else:
        lst.append(num)
        num = (num // A[cnt]) * A[i]
        cnt += 1
lst.append(num)

for i in range(len(lst) - 1):
    if (lst[i] < lst[i+1]):
        print('Yes')
    else:
        print('No')

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

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

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

for i in range(k,n):
    before = memo[i-1]
    after = 1
    for j in range(k):
        after *= a[i-j]
    
    if before < after:
        print("Yes")
    else:
        print("No")
    
    memo[i] = after



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

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

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

for i in range(K, N):
    if 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(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()))

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

first = k_mul
for i in range(k, n):
    new = (first // a[i-k]) * a[i]
    if first < new:
        print("Yes")
    else:
        print("No")
    first = new

# 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, A):
    for i in range(K-1, N): # 0 から数えるから K-1
        # 総積
        this = A[i-(K-1):i+1]   # 直近3学期． i+1はスライスのときその数字は入らないから．

        # print
        if i != K-1:
            if this[-1] > before[0]:
                print('Yes')
            else:
                print('No')
        before = this


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

# Optimized solution
def main(N, K, A):
    for i in range(K, N): # 0 から数えるから K-1
        this = A[i]
        before = A[i-K]

        if this > before:
            print('Yes')
        else:
            print('No')



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


s1 = 1
s2 = 1
for i in range(k):
  s1 = s1 * a[i]
  s2 = s2 * a[i+1]

if s1 < s2:
  print("Yes")
else:
  print("No")


for i in range(1,n-k):
  s1 = s2
  s2 = int(s1 / a[i] * a[k+i])
    
  if s1 < s2:
    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[k+i]:
    print("Yes")
  else:
    print("No")
# Original solution
import functools


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

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

answers = []

prev_mul_scores_last_k = functools.reduce(lambda acc, score: acc * score, scores[:k])

prev_score = scores[0]

for i in range(k, n):
    mul_scores_last_k = (prev_mul_scores_last_k // prev_score) * scores[i]

    if prev_mul_scores_last_k < mul_scores_last_k:
        answers.append('Yes')
    else:
        answers.append('No')

    prev_mul_scores_last_k = mul_scores_last_k
    prev_score = scores[i - (k - 1)]

for answer in answers:
    print(answer)


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

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

answers = []

prev_score = scores[0]

for i in range(k, n):
    if prev_score < scores[i]:
        answers.append('Yes')
    else:
        answers.append('No')

    prev_score = scores[i - (k - 1)]

for answer in answers:
    print(answer)
# Original solution
N, K = list(map(int, input().strip().split(" ")))
scores = input().strip().split(" ")
i = 0
grade = 1
for i in range(K):
    grade *= int(scores[i])

for i in range(K, N):
    last = grade
    grade = int(grade / int(scores[i-K]))
    grade *= int(scores[i])
    if (grade > last):
        print("Yes")
    else:
        print("No")

# Optimized solution
N, K = list(map(int, input().strip().split(" ")))
scores = input().strip().split(" ")

for i in range(K, N):
    if (int(scores[i]) > int(scores[i-K])):
        print("Yes")
    else:
        print("No")
# Original solution
n,k=(int(i) for i in input().split())
l=[int(i) for i in input().split()]
l1=[0]*(k-1)+[1]
for i in range(k):
    l1[k-1]*=l[i]
for i in range(k,n):
    l1+=[(l1[i-1]//l[i-k])*l[i]]
for i in range(k,n):
    if(l1[i]>l1[i-1]):
        print("Yes")
    else:
        print("No")

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

x = [1]*(a[0]-a[1]+1)

for i in range(a[1]-1,len(b)):
    for j in range(0,a[1]):
        x[i-(a[1]-1)] = x[i-a[1]+1]*b[i-j]

for i in range(1, len(x)):
    if int(x[i]) > int(x[i-1]):
        print("Yes")
    else:
        print("No")

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

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

ans = []

for i in range(n-k):
    if (a[i+k] == 0):
        ans.append("No")
        continue

    if (0 in a[i:i+k-1]):
        ans.append("Yes")
        continue

    if (a[i] < a[i+k]):
        ans.append("Yes")
    else:
        ans.append("No")

for i in range(len(ans)):
    print((ans[i]))


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

ans = []
for i in range(n-k):
    if (a[i] < a[i+k]):
        ans.append("Yes")
    else:
        ans.append("No")

for i in range(len(ans)):
    print((ans[i]))
# Original solution
import os, sys, atexit
from io import BytesIO, StringIO
 
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
_OUTPUT_BUFFER = StringIO()
sys.stdout = _OUTPUT_BUFFER
 
@atexit.register
def write():
    sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
ans = [0] * (n - k + 1)
x = 0
for i in range(1, n):
    l[i] *= l[i - 1]
for i in range(k - 1, n):
    if i == k - 1:
        ans[x] = l[i]
        x -= -1
    else:
        ans[x] = l[i] // l[i - k]
        x -= -1
for i in range(1, len(ans)):
    if ans[i] > ans[i - 1]: print('Yes')
    else: print('No')

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

# 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 sys import stdin,stdout
def fn(i):
    return pro[i]//(pro[i-k] if i-k>=0 else 1)
n,k=list(map(int,stdin.readline().split()))
a=list(map(int,stdin.readline().split()))
pro=[a[0]]
for v in a[1:]:
    pro+=[pro[-1]*v]
for i in range(k,n):
    #print(fn(i),fn(i-1))
    if fn(i)>fn(i-1):print('Yes')
    else:print('No')


# Optimized solution
from sys import stdin,stdout
n,k=list(map(int,stdin.readline().split()))
a=list(map(int,stdin.readline().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(map(int, input().split()))
score = 1

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

prev = score
for i,j in zip(list(range(K, N)), list(range(N-K))):
    score /= A[j]
    score *= A[i]
    print(("Yes" if score > prev else "No"))
    prev = score

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

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

# point = [0] * (N - K + 1)
tmplist = A[0:K]
tmppoint = tmplist[0]
for j in range(1, K):
    tmppoint = tmppoint * tmplist[j]
point = tmppoint


for i in range(1, N - K + 1):
    tmplist = A[i : i + K]
    tmppoint = tmplist[0]

    for j in range(1, K):
        tmppoint = tmppoint * tmplist[j]

    if point < tmppoint:
        print("Yes")
    else:
        print("No")

    point = tmppoint



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

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

point = []

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

for i in range(1,n-k+1):

    if(point[i-1] >= point[i]):
        print("No")
    else:
        print("Yes")


# Optimized solution

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

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

#この段階でrepはK学期の評価
tmp = rep
for i in range(K,N):
    tmp = rep*A[i]//A[i-K]
    if tmp > rep:
        print("Yes")
    else:
        print("No")
    rep = tmp


# Optimized solution
mod = 10**9 +7
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()))
LIST_A = list(map(int,input().split()))


import functools
import operator

for i in range(N-K):
  target_1 = LIST_A[i:i+K]
  target_2 = LIST_A[i+1:i+K+1]
  #print(target_1,target_2)
  result_1 = functools.reduce(operator.mul, target_1)
  result_2 = functools.reduce(operator.mul, target_2)
    
  if result_1 < result_2:
    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):
  target_1 = LIST_A[i+K]-LIST_A[i]  
  if target_1 > 0:
    print("Yes")
  else:
    print("No")
# Original solution
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A_max=max(A)
for i in A:
    i=i/A_max
ans=list()
tmp=1
for i in range(K):
    tmp=tmp*A[i]
for i in range(K,N):
    tmp_old=tmp
    tmp=tmp_old*A[i]/A[i-K]
    if tmp_old<tmp:
        ans.append('Yes')
    else:
        ans.append('No')
for i in ans:
    print(i)

# Optimized solution
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
ans=list()
for i in range(K,N):
    if A[i-K]<A[i]:
        ans.append('Yes')
    else:
        ans.append('No')
for i in ans:
    print(i)
# Original solution
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')

if __name__ == '__main__':
    main()


# Optimized solution
def main():
    n, k = map(int, input().split())
    A = list(map(int, input().split()))
    [print('Yes') if a < b else print('No') for a, b in zip(A[:n - k], A[k:])]

if __name__ == '__main__':
    main()
# Original solution
n, k = map(int, input().split())
A = list(map(int, input().split()))

mul = [1]
for i in range(n):
    mul.append(mul[i] * A[i])
#print(mul)
output = []
for i in range(k+1, n+1):
    if mul[i]/mul[i-k] > mul[i-1]/mul[(i-1)-k]: output.append("Yes")
    else: output.append("No")
print(*output, sep="\n")


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

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

output = []
count = 0
for i in range(k, n):
    if tmp < int(tmp * A[i] / A[count]):
        output.append("Yes")
    else:
        output.append("No")
    tmp = int(tmp * A[i] / A[count])
    count += 1
    
print(*output, sep="\n")
# Original solution
n, k = map(int, input().split())
A = list(map(int, input().split()))

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

output = []
count = 0
for i in range(k, n):
    if tmp < int(tmp * A[i] / A[count]):
        output.append("Yes")
    else:
        output.append("No")
    tmp = int(tmp * A[i] / A[count])
    count += 1
    
print(*output, sep="\n")


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

output = []
count = 0
for i in range(k, n):
    if A[i] > A[count]:
        output.append("Yes")
    else:
        output.append("No")
    count += 1
    
print(*output, sep="\n")
# Original solution
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())

def main():
  n,k=LI()
  l=LI()
  ind=0

  sm=1
  for i in range(k):
    sm*=l[i]

  before=sm
  ans=[]
  nxt=k
  for _ in range(n-k):
    sm//=l[ind]
    sm*=l[nxt]

    if before<sm:
      ans.append('Yes')
    else:
      ans.append('No')

    before=sm
    ind+=1
    nxt+=1

  for x in ans:
    print(x)

main()
# print(main())


# Optimized solution
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())

def main():
  n,k=LI()
  l=LI()

  ind=0
  nxt=k
  ans=[]
  for _ in range(n-k):
    if l[ind]<l[nxt]:
      ans.append('Yes')
    else:
      ans.append('No')

    ind+=1
    nxt+=1

  for x in ans:
    print(x)

main()
# print(main())
# Original solution
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
ave=[0 for i in range(n-k+1)]

for i in range(n-k+1):
    temp=1
    for s in range(i,i+k):
        temp*=A[s]
    ave[i]=temp

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

# Optimized solution
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
ave=[0 for i in range(n-k+1)]


for i in range(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()))
ans=[0]*(n-k+1)
r=1
for i in range(k):
    r=r*a[i]
ans[0]+=r
for i in range(1,n-k+1):
    ans[i]+=(ans[i-1]*a[i+k-1])//a[i-1]
    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()))
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_arr = list(map(int, input().split()))

k_idx = K - 1
term_val_arr = []
ans_arr = []
for i in range(N - K + 1):
    val = 1
    if len(term_val_arr) == 0:
        for j in range(K):
            val *= a_arr[k_idx - j]
        term_val_arr.append(val)
    else:
        term_val_arr.append(a_arr[k_idx] * term_val_arr[i - 1] / a_arr[i-1])

    if i != 0:
        if term_val_arr[i - 1] < term_val_arr[i]:
            ans_arr.append('Yes')
        else:
            ans_arr.append('No')
    k_idx += 1
for i in ans_arr:
    print(i)

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

k_idx = K - 1
ans_arr = []
for i in range(N - K):
    if a_arr[i] < a_arr[k_idx + 1]:
        ans_arr.append('Yes')
    else:
        ans_arr.append('No')
    k_idx += 1
for i in ans_arr:
    print(i)
# Original solution
n, k = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
p = 1
for i in range(k):
    p *= arr[i]
for i in range(k, n):
    l = p
    l /= arr[i-k]
    l *= arr[i]
    if l > p:
        print("Yes")
    else:
        print("No")
    p = l

# Optimized solution
n, k = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
for i in range(k, n):
    if arr[i] > arr[i-k]:
        print("Yes")
    else:
        print("No")
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
l = [0]*(n-k+1)
t = 1
for i in range(k):
    t *= a[i]
l[0] = t
for i in range(1,n-k+1):
    t = t//a[i-1]
    t = t*a[k+i-1]
    l[i] = t
for i in range(n-k):
    if l[i] < l[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
import math
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
count=0
before=0
now=1


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

# Optimized solution
import math
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
count=0
before=0
now=1


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

sum=1

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

hoge=[0 for i in range(n)]

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

for i in range(k,n):
    #print(hoge[i-1],hoge[i],end=" ")
    if hoge[i-1]<hoge[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):
    #print(hoge[i-1],hoge[i],end=" ")
    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()))
old=1
for j in range(k):
	old*=a[k-1-j]
for i in range(n-k+1):
	new=1
	for s in range(k):
		new*=a[k-1-s+i]
	if i>0 and new>old:
		print('Yes')
	elif i>0 and new<=old:
		print('No')
	old=new

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

tmp = 1

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

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



# Optimized solution
N, K = (int(i) for i in input().split())
A = [int(i) for i in 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()))
prev = 1
for i in range(k):
  prev *= a[i]
for i in range(k,n):
  cur = (prev//a[i-k])*a[i]
  print(("Yes" if cur > prev else "No"))
  prev = cur

# Optimized solution
import math as m

n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
prev = 1
for i in range(k):
  prev += m.log(a[i])
for i in range(k,n):
  cur = prev + m.log(a[i])
  cur -= m.log(a[i-k])
  print(("Yes" if cur > prev else "No"))
  prev = cur
# Original solution
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
s=[]
for j in range(K-1,N):
    score=1
    for i in range(j-K+1,j+1):
        score*=A[i]
    s.append(score)
    
for i in range(len(s)-1):
    if s[i]<s[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
#!/usr/bin/env python3

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

    point = [1] * K
    point[0] = A[0]

    for i in range(1, K):
        point[i] = point[i - 1] * A[i]

    ans = ['No'] * (N - K)
    p = point[K - 1]
    for i in range(N - K):
        tmp = p * A[K + i] / A[i]
        if p < tmp:
            ans[i] = 'Yes'
        p = tmp
    print(("\n".join(ans)))

if __name__ == "__main__":
    main()


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

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

    ans = ['No'] * (N - K)
    for i in range(N - K):
        tmp = A[K + i] / A[i]
        if 1 < tmp:
            ans[i] = 'Yes'
    print(("\n".join(ans)))


if __name__ == "__main__":
    main()
# Original solution
sem, per = list(map(int, input().split()))
scores = list(map(int, input().split()))
period_score = []

for i in range(len(scores) - (per - 1)):
    period = scores[i:per + i]
    temp = period[0]
    for j in range(1, per):
        temp *= period[j]
        
    period_score.append(temp)
    
for k in range(1, len(period_score)):
    if period_score[k - 1] < period_score[k]:
        print('Yes')
    else:
        print('No')

# Optimized solution
sem, per = list(map(int, input().split()))
scores = list(map(int, input().split()))

for i in range(sem - per):
    if scores[i] < scores[i + per] :
        print('Yes')
    else:
        print('No')