CodeEff/ECCO huggingface dataset:
# Original solution
#!/usr/bin/env python
# coding: utf-8

# In[2]:


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


# In[3]:


def main():
    x0 = 1
    for i in range(K):
        x0 *= A[i]
    x = x0
    for j in range(K,N):
        score = x*A[j]//A[j-K]
        if score > x:
            print("Yes")
        else:
            print("No")
        x = score


# In[4]:


if __name__ == '__main__':
    main()


# In[ ]:






# Optimized solution
#!/usr/bin/env python
# coding: utf-8

# In[2]:


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


# In[9]:


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


# In[10]:


if __name__ == '__main__':
    main()


# In[ ]:
# Original solution
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
temp = 1
for i in range(N):
    before = temp
    temp *= A[i]
    if i >= K:
        temp /= A[i-K]
        if temp > before:
            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):
    if i >= K:
        if A[i] > A[i-K]:
            print("Yes")
        else:
            print("No")
# Original solution
from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))

n,k=nii()
a=lnii()

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

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

# Optimized solution
from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))

n,k=nii()
a=lnii()

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

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


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


# 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()))
def score(A,N,K):
    s=1
    for i in range(N-K+1,N+1):
        s*=A[i]
    return s

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


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

score = 1
for each in list_a[0:k]:
    score *= each
    
for i, next_score in enumerate(list_a[k:]):
    score_before = score
    score = score_before * next_score / list_a[i]
    if score > score_before:
        print('Yes')
        continue
    print('No')

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

band_score = 1
    
for i, score in enumerate(list_a[k:]):
    if list_a[i] < score:
        print('Yes')
        continue
    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,n):
    score_b = score
    score = score_b/a[i-k]*a[i]
    
    if score_b < score:
        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):
    zenkai = a[i-k]
    konkai = a[i]
    if zenkai < konkai:
        print("Yes")
    else:
        print("No")
# Original solution
n,k = list(map(int,input().split()))
a = [int(n) for n in input().split()]

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

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


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

for i in range(k,n):
    if (a[i] > a[i - k]):
        print("Yes")
    else:
        print("No")
# Original solution
import functools
import operator

N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
R = []
for i in range(N-K+1):
  X = functools.reduce(operator.mul,A[i:i+K])
  R.append(X)
  if i ==0:
    continue
  else:
    if X > R[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-1,N-1):
  if A[i-(K-1)] < A[i+1]:

    print("Yes")
  else:
    print("No")
# Original solution
import functools
import operator

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

prod = functools.partial(functools.reduce, operator.mul)
tmp_sum_prod = prod(A[:K])
for i in range(K, N):
    sum_prod = int(tmp_sum_prod * A[i]/A[i-K])
    if sum_prod > tmp_sum_prod:
        print('Yes')
    else:
        print('No')
    tmp_sum_prod = sum_prod


# Optimized solution
import functools
import operator

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

# prod = functools.partial(functools.reduce, operator.mul)
# tmp_sum_prod = prod(A[:K])
for i in range(K, N):
    sum_prod = (A[i]/A[i-K])
    if sum_prod > 1.0:
        print('Yes')
    else:
        print('No')
    tmp_sum_prod = sum_prod
# Original solution
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
limit, mul, m = n-k+1, [], 1
for i in range(limit):
    if i == 0:
        for j in a[i: k+i]:
            m *= j
    else:    
        print(('Yes' if m < (m//a[i-1])*a[k+i-1] else 'No'))
        m = (m//a[i-1])*a[k+i-1]

# 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()))
l=[]
score=1
for i in range(k):
    score*=a[i]
l.append(score)
m=k
d=0
multi=a[m]
div=a[d]
for i in range(k+1,n+1):
    score=(score*a[m])//a[d]
    l.append(score)
    m+=1
    d+=1
old=l[0]
for i in range(1,len(l)):
    if l[i]<=old:
        print("No")
    else:
        print("Yes")
    old=l[i]


# Optimized solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
m=k
d=0
for i in range(k+1,n+1):
    if a[m]<=a[d]:
        print("No")
    else:
        print("Yes")
    m+=1
    d+=1
# Original solution
#!/usr/bin python3
# -*- coding: utf-8 -*-

N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
Hk = 1
for i in range(K):
    Hk*=A[i]

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


# Optimized solution
#!/usr/bin python3
# -*- coding: utf-8 -*-

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

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  #空白あり
def LS2(): return list(sys.stdin.readline().rstrip())  #空白なし

N,K = MI()
A = [0] + LI()

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



# Optimized solution
import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  #空白あり

N,K = MI()
A = [0] + LI()

for i in range(K+1,N+1):
    print(('Yes' if A[i] > A[i-K] else 'No'))
# Original solution
from itertools import accumulate
from operator import mul
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    N, K = list(map(int, input().split()))
    A = tuple(map(int, input().split()))

    point = list(accumulate(A[:K], mul))
    for i in range(K, N):
        point.append(point[-1] * A[i] // A[i - K])
    for i in range(K, N):
        if point[i - 1] < point[i]:
            print("Yes")
        else:
            print("No")


main()


# Optimized solution
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    N, K = list(map(int, input().split()))
    A = tuple(map(int, input().split()))

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


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

evals = []
eval = scores[0:k]
for i in range(k, n, 1):
    new = scores[i-k+1:i+1]
    if eval[0] < new[-1]:
        evals.append('Yes')
    else:
        evals.append('No')
    eval = new

for ans in evals:
    print(ans)

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

evals = []
cnt = 0

for i in range(k, n, 1):
    edge = scores[cnt]
    new_edge = scores[i]
    if edge < new_edge:
        print('Yes')
    else:
        print('No')
    cnt += 1
# Original solution
n, k = list(map(int, input().split()))

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

wk = 1
li_answer = list()
for idx, v in enumerate(li_a):
    prev = wk
    if idx <= (k - 1):
        wk = wk * v
    else:
        wk = wk * v // li_a[idx - k]
        if prev >= wk:
            print('No')
        else:
            print('Yes')




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

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

for idx, v in enumerate(li_a):
    if idx <= (k - 1):
        pass
    else:
        if v > li_a[idx - k]:
            print('Yes')
        else:
            print('No')
# Original solution
from collections import deque

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

# まずスタートの点数
p_pre = 1
for item in a[:k]:
    p_pre *= item

# n-k回やる
for i in range(n-k):
    # iこ目をなくしてk+iこめをふやす
    p_next = ((p_pre / a[i]) * a[k+i])
    if p_next > p_pre:
        print("Yes")
    else:
        print("No")

    p_pre = p_next


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

# n-k回やる
for i in range(n-k):
    # iこ目をなくしてk+iこめをふやす
    if a[k+i] > a[i]:
        print("Yes")
    else:
        print("No")
# Original solution
import copy
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
b = copy.deepcopy(a)
for i in range(K-1, N, 1):
  for j in range(1, K):
    b[i] *= a[i-j]
  if i >= K and b[i] > b[i-1]:
    print("Yes")
  if i >= K and b[i] <= b[i-1]:
    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
def LI():
  return list(map(int,input().split()))
  
n,k=LI()
a=LI()

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

# print(fir)

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

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

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

# Optimized solution
n,k,*a=list(map(int,open(0).read().split()))
for i in range(n-k):
  if a[i]<a[i+k]:
    print("Yes")
  else:
    print("No")
# Original solution
f=lambda:[*list(map(int,input().split()))]
n,k=f()
ｌ=f()
for i in range(n-k):
  print(('YNeos'[l[i]>=l[i+k]::2]))

# Optimized solution
n,k,*l=list(map(int,open(0).read().split()))
for i in range(n-k): print(('YNeos'[l[i]>=l[i+k]::2]))
# Original solution
import operator
import functools

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

    for i in range(K-1,N):
        lst= A[i-K+1:i+1]
        p = sum(lst)
        #p = mul(lst)
        #p = functools.reduce(operator.mul,lst)
        if i != K-1:
            if p <= prev:
                print('No')
            else:
                print('Yes')
        prev = p
    
if __name__ == "__main__":
    main()
    

# Optimized solution
def main():
    N,K = list(map(int,input().split()))
    A = list(map(int,input().split()))
    p  = 0
 
    for i in range(K-1,N):
        #lst= A[i-K+1:i+1]
        #p = sum(lst)
        #p = mul(lst)
        #p = functools.reduce(operator.mul,lst)
        if i != K-1:
            if A[i] <= A[i-K]:
                print('No')
            else:
                print('Yes')
        
    
if __name__ == "__main__":
    main()
# Original solution
N, K = list(map(int, input().split()))
A = list(int(a) for a in input().split())

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

for j in range(K, N):
    now = Acum[j] // Acum[j-K]
    nxt = Acum[j+1] // Acum[j+1-K]
    if now < nxt:
        print('Yes')
    else:
        print('No')

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

B = []
tmp = 1
for i in range(N):
    tmp *= A[i]
    if i < K-1:
        continue
    if i > K-1:
        tmp //= A[i-K]
    B.append(tmp)

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

st = 1 #k楽器
for i in range(k):
    st *= a[i]

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


# 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()))
an = list(map(int, input().split()))

from functools import reduce
prod = reduce(lambda x,y: x*y, an[:k])

for i in range(k, n):
    prod_next = prod // an[i - k] * an[i]
    print((['No', 'Yes'][prod_next > prod]))
    prod = prod_next


# Optimized solution
n, k = list(map(int, input().split()))
an = list(map(int, input().split()))
            
ank = an[:k]
for i in range(k, n):
    print((['No', 'Yes'][an[i] > ank[0]]))
    ank.pop(0)
    ank.append(an[i])
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
x = 1
for i in range(n):
    if i<k:
        x *= a[i]
    else:
        c = x//a[i-k]*a[i]
        print(('Yes' if c>x else 'No'))
        x = c

# Optimized solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(n):
    if i>=k:
        print(('Yes' if a[i-k]<a[i] else 'No'))
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = a[:]
for i in range(1,k):
    a[i] = a[i] * a[i-1]
for i in range(k,n):
    a[i] = a[i] * a[i-1] // b[i-k]
    if a[i] > a[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
from functools import reduce

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

# 評点計算

# s[0]~s[k-2]まで0埋め
s = [0 for _ in range(k-1)]

# s[n-k] = a[0] * a[1] * ... * a[n-k]
s.append(reduce(lambda x, y: x*y, [a[i] for i in range(0, n-k+1)]))

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

# 出力
for i in range(k, n):
    print(("Yes" if s[i] > s[i-1] else "No" ))

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

for i in range(k-1, n-1):
    print(("Yes" if a[i+1] > a[i-k+1] else "No"))
# Original solution
import sys
input=sys.stdin.readline
n,k=list(map(int,input().split()))
arr=list(map(int,input().split()))
prev=1
for i in range(k):
    prev*=arr[i]
ans=[]
for i in range(k,n):
    if(prev<prev*arr[i]/arr[i-k]):
        print('Yes')
    else:
        print('No')
    prev=prev*arr[i]/arr[i-k]
           
        

    

# Optimized solution
import sys
input=sys.stdin.readline
n,k=list(map(int,input().split()))
arr=list(map(int,input().split()))

for i in range(k,n):
    if(arr[i-k]<arr[i]):
        print('Yes')
    else:
        print('No')
# Original solution
from functools import reduce
import operator

n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cnt, precnt = 0, reduce(operator.mul, a[:k])

for i in range(1, n-k+1):
    cnt = reduce(operator.mul, a[i:k+i])
    if cnt > precnt:
        print("Yes")
    else:
        print("No")
    precnt = cnt



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

for i in range(n-k):
    if a[i] >= a[k+i]:
        print("No")
    else:
        print("Yes")
# Original solution
n,k=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
mark=[0]*(n-k+1)
m=[1]*(k+1)
for i in range(k):
  m[i+1]=a[i]*m[i]
mark[0]=m[k]
for j in range(1,n-k+1):
  mark[j]=(mark[j-1]/a[j-1])*a[j+k-1]
  if mark[j-1]<mark[j]:
    print("Yes")
  else:
    print("No")

# Optimized solution
n,k=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
for i in range(n-k):
  if a[i]<a[i+k]:
    print("Yes")
  else:
    print("No")
# Original solution
from operator import mul
from functools import reduce

[n,k] = list(map(int, input().split(' ')))
A = list(map(int, input().split(' ')))

def hyoka(j,p,b_point):
  if j == k:
    point = reduce(mul, A[0:j])
    return point
  else:
    point = b_point/A[j-k-1]*p
    
  if b_point < point:
    print('Yes')
  else:
    print('No')
  return point
b_point = 0
for j,p in enumerate(A[k-1:n+1]):
  i = j+k-1
  result = hyoka(i+1,p,b_point)
  if result > 0:
  	b_point = result


# 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=[int(i) for i in input().split()]
ans=[a[0]]

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

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

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

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(n-k):
        print(("Yes" if a[i] < a[i+k] else "No"))

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

a_lst = list(map(int, input().split(" ")))

# previousの値を取っておいて真に掛け算した評定が高かったかを判定
previous = 1
for i in range(k):
    previous *= a_lst[i]
for i in range(k, n):
    now = previous / a_lst[i - k] * a_lst[i]
    if now > previous:
        print("Yes")
    else:
        print("No")
    previous = now


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

a_lst = list(map(int, input().split(" ")))

for i in range(k, n):
    if a_lst[i] > a_lst[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()))
    tmp = 1
    for i in range(K):
        tmp *= A[i]

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

if __name__ == '__main__':
    main()

# Optimized solution
import sys
input = sys.stdin.readline
def main():
    N, K = list(map(int, input().split()))
    A = list(map(int, input().split()))
    # tmp = 1
    # for i in range(K):
    #     tmp *= A[i]
    # print(tmp)

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

if __name__ == '__main__':
    main()
# Original solution
from sys import stdin


def readline_from_stdin() -> str:
    return stdin.readline().rstrip


if __name__ == '__main__':
    N, K, = input().split()
    A = [int(i) for i in input().split()]
    N, K = int(N), int(K)

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

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

    # scores = [score]
    # for i in range(N-K):
    #     print(i, K+i)
    #     score = int(score / A[i]) * A[K+i]
    #     scores.append(score)
    #
    # print(scores)
    #
    # results = [False for i in range(len(scores)-1)]
    #
    # for i in range(len(scores)-1):
    #     results[i] = scores[i+1] > scores[i]
    #
    # [print("Yes") if r else print("no") for r in results]


# Optimized solution
from sys import stdin


def readline_from_stdin() -> str:
    return stdin.readline().rstrip


if __name__ == '__main__':
    N, K, = input().split()
    A = [int(i) for i in input().split()]
    N, K = int(N), int(K)

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