CodeEff/ECCO huggingface dataset:
# Original solution
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline    ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np    # cumsum
# from bisect import bisect_left, bisect_right

def solve():
    N, K = MI()
    A = LI()

    B = [1] * N
    B[0] = A[0]
    for i in range(1, N):
        B[i] = B[i-1] * A[i]
    # print(B)

    B = [1] + B

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


if __name__ == '__main__':
    solve()


# Optimized solution
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline    ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np    # cumsum
# from bisect import bisect_left, bisect_right

def solve():
    N, K = MI()
    A = LI()

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

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

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

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

# 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 solve(ns, k):
    n = len(ns)
    tot = 1
    for i in range(k):
        tot *= ns[i]
    res = []
    pre = tot
    for i in range(k, n):
        tot /= ns[i - k]
        tot *= ns[i]
        if tot > pre:
            res.append(True)
        else:
            res.append(False)
        pre = tot
    return res

assert solve([96, 98, 95, 100, 20], 3) == [True, False]
assert solve([1001, 869120, 1001], 2) == [False]
assert solve([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9], 7) == [True, True, False, True, True, False, True, True]


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

res = solve(ns, k)
for item in res:
    print('Yes' if item else 'No')




# Optimized solution
def solve(ns, k):
    n = len(ns)
    tot = 1
    for i in range(k):
        tot += ns[i]
    res = []
    pre = tot
    for i in range(k, n):
        a = ns[i - k]
        b = ns[i]
        if a > b:
            # tot = tot / a * b
            tot = tot - 1
        elif a < b:
            tot = tot + 1
        else:
            pass
        if tot > pre:
            res.append(True)
        else:
            res.append(False)
        pre = tot
    return res

assert solve([1001, 869120, 1001], 2) == [False]
assert solve([96, 98, 95, 100, 20], 3) == [True, False]
assert solve([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9], 7) == [True, True, False, True, True, False, True, True]


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

res = solve(ns, k)
for item in res:
    print('Yes' if item else 'No')
# Original solution
import functools
import operator

n, k = list(map(int, input().split()))
a = [int(s) for s in input().split()]
vals = []
for i in range(k - 1, n):
    vals.append(functools.reduce(operator.mul, a[i - k + 1:i + 1]))

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

# Optimized solution
n, k = list(map(int, input().split()))
a = [int(s) for s in 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()))

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

# 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 = [0] * (N)
temp[0] = A[0]

for i in range(1, N):
  temp[i] = temp[i - 1] * A[i]

ans[0] = A[0]
for i in range(N):
  ans[i] = temp[i]
  if i >= K:
    ans[i] /= temp[i - K]

for i in range(K, N):
  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(K, N):
  if A[i] > A[i - K]:
    print('Yes')
  else:
    print('No')
# Original solution
#!/usr/bin/env python3
import collections as cl
import sys


def II():
    return int(sys.stdin.readline())


def MI():
    return list(map(int, sys.stdin.readline().split()))


def LI():
    return list(map(int, sys.stdin.readline().split()))


def main():
    n, k = MI()
    scores = LI()

    score_now = 1

    for i in range(k):
        score_now *= scores[i]

    for i in range(k, n):
        next_score = score_now * (scores[i] / scores[i - k])
        print(("Yes" if next_score > score_now else "No"))


main()


# Optimized solution
#!/usr/bin/env python3
import collections as cl
import sys


def II():
    return int(sys.stdin.readline())


def MI():
    return list(map(int, sys.stdin.readline().split()))


def LI():
    return list(map(int, sys.stdin.readline().split()))


def main():
    n, k = MI()
    scores = LI()

    score_now = 1

    for i in range(k, n):
        next_score = scores[i] / scores[i - k]
        print(("Yes" if next_score > 1 else "No"))


main()
# Original solution
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
a=1

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

# 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("No")
    continue
  else:
    print("Yes")
    continue
# Original solution
N, K = list(map(int, input().split()))
score = list(map(int, input().split()))
add = []
sc = 1
for i in score:
    sc *= i
    add.append(sc)
pre = 0
for i in range(K - 1, N):
    if i == K - 1:
        cur = add[i]
    else:
        cur = add[i] // add[i - K]
        print(("Yes" if cur > pre else "No"))
    pre = cur


# Optimized solution
N, K = list(map(int, input().split()))
score = list(map(int, input().split()))
add = []
sc = 1
for i in range(K):
    sc *= score[i]
add.append(sc)
for i in range(K, N):
    sc = sc // score[i-K]
    sc *= score[i]
    add.append(sc)
pre = 0
for num, val in enumerate(add):
    if num != 0:
        print(("Yes" if val > pre else "No"))
    pre = val
# Original solution
from collections import deque
N, K = list(map(int, input().split()))
score = list(map(int, input().split()))
add = deque()
sc = 1
for i in range(K):
    sc *= score[i]
add.append(sc)
for i in range(K, N):
    sc = sc // score[i-K]
    sc *= score[i]
    add.append(sc)
pre = 0
for num, val in enumerate(add):
    if num != 0:
        print(("Yes" if val > pre else "No"))
    pre = val

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


for gakki in range(k+1,n+1):
    pre = A[gakki-k-1:gakki-1]
    #pre_ = 1
    #for p in pre:
        #pre_ *= p

    
    k_gakki = A[gakki-k:gakki]
    #k_gakki_ = 1
    #for ga in k_gakki:
        #k_gakki_ *= ga
    
    #if pre_ < k_gakki_:
    if pre[0] < k_gakki[-1]:
        print('Yes')
    else:
        print('No')

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


for gakki in range(k+1,n+1):
    #pre = A[gakki-k-1:gakki-1]
    pre = A[gakki-k-1]
    #pre_ = 1
    #for p in pre:
        #pre_ *= p

    
    #k_gakki = A[gakki-k:gakki]
    k_gakki = A[gakki-1]
    #print(k_gakki)
    #k_gakki_ = 1
    #for ga in k_gakki:
        #k_gakki_ *= ga
    
    #if pre_ < k_gakki_:
    if pre < k_gakki:
        print('Yes')
    else:
        print('No')
# Original solution
n,k = list(map(int,input().split()))
arr = list(map(int,input().split()))

brr = []
prod = 1
for i in range(k):
    prod*=arr[i]

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


# Optimized solution
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 collections import deque
from functools import reduce

N, K = [int(n) for n in input().split()]
scores = [int(n) for n in input().split()]

d = deque(maxlen=200001)
for i, score in enumerate(scores, start=1):
    if i < K:
        d.append(score)
    elif i == K:
        d.append(score)
        pre_e = reduce(lambda x, y: x*y, d)
        d.popleft()
    else:
        d.append(score)
        e = reduce(lambda x, y: x*y, d)
        if e > pre_e:
            print('Yes')
        else:
            print('No')
        pre_e = e
        d.popleft()


# Optimized solution
N, K = [int(n) for n in input().split()]
scores = [int(n) for n in input().split()]
min_pointer = 0
max_pointer = K
for i, score in enumerate(scores, start=1):
    if i > K:
        if scores[max_pointer] > scores[min_pointer]:
            print('Yes')
        else:
            print('No')
        min_pointer += 1
        max_pointer += 1
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))  # (N,)

score_i = 1
for a_i in A[:K]:
    score_i *= a_i

for i in range(K, N):
    new_score_i = A[i] * score_i // A[i - K]
    if score_i < new_score_i:
        print('Yes')
    else:
        print('No')
    score_i = new_score_i


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

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

# 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+K]>A[i] else "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):
	next = prev // A[i-K] * A[i]
	print(('Yes' if next > prev else 'No'))
	prev = next


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

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
import sys
input=sys.stdin.readline

def mult(x, y):
    z = 0
    while y > 0:
        if y % 2 == 1: z = z + x
        x = x << 1
        y = y >> 1
    return z
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[]
p=1
for i in range(n):
    p=mult(p,a[i])

    if i>=k-1:
        b.append(p)
        p=p//a[i-k+1]

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


# Optimized solution
import sys
input=sys.stdin.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 = tuple(map(int, input().split(' ')))

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

pre = mul

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


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

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


    

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


tmp=1
before_score=0
for i in range(K,N):
  if i>=K-1:
    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 = []
tmp = 1

for i in range(n):
    tmp *= a[i]
    if i >= k:
        tmp //= a[i-k]
    if i >= k-1:
        b.append(tmp)

for i in range(1, len(b)):
    if b[i] > b[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()))
B = []

def product(array):
  a = 1
  for k in array:
    a *= k
  return a

for i in range(N-K+1):
  B.append(product(A[i:i+K]))
  
count = 0
for b in B:
  if count == 0:
    b_old = b
  else:
    if b > b_old:
      print('Yes')
    else:
      print('No')
  b_old = b
  count += 1

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

sum_A = [0]*N
sum_A_k = 1
for i in range(K):
  sum_A_k = sum_A_k*A[i]
sum_A[K-1] = sum_A_k

for i in range(N-K):
  sum_A[K+i] = sum_A[K-1+i]*A[K+i]/A[i]
  if sum_A[K+i] > sum_A[K-1+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[K+i]/A[i] > 1:
    print('Yes')
  else:
    print('No')

# sum_A = [0]*N
# sum_A_k = 1
# for i in range(K):
#   sum_A_k = sum_A_k*A[i]
# sum_A[K-1] = sum_A_k

# for i in range(N-K):
#   sum_A[K+i] = sum_A[K-1+i]*A[K+i]/A[i]
#   if sum_A[K+i] > sum_A[K-1+i]:
#     print('Yes')
#   else:
#     print('No')
# Original solution
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
scores=[]
for i in range(N-K+1):
  score=1
  for j in range(i,i+K):
    score*=A[j]
  scores.append(score)

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

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

hyoten = 1

for idx, a in enumerate(A):
    if idx < K:
        hyoten *= a
    else:
        next_hyoten = hyoten * a / A[idx - K]
        if next_hyoten <= hyoten:
            print('No')
        else:
            print('Yes')
        hyoten = next_hyoten

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

for idx, a in enumerate(A):
    if idx < K:
        continue
    else:
        if a <= A[idx - K]:
            print('No')
        else:
            print('Yes')
# Original 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')

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

for i in range(K+1, N+1):
    if A[i-K] >= A[i]:
        print('No')
    else:
        print('Yes')
# Original solution
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 25 17:57:31 2020

@author: Paras
"""

n,k = list(map(int, input().split()))
marks = list(map(int, input().split()))
score_curr = 1
for i in range(k):
  score_curr*=marks[i]
  
f = marks[0]
score_prev = score_curr
j = 0
for i in range(k,n):
    score_curr = (score_prev//f)*marks[i]
    if score_curr>score_prev:
        print("Yes")
    else:
        print("No")
    score_prev = score_curr
    j+=1
    f = marks[j]

# Optimized solution
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 25 17:57:31 2020

@author: Paras
"""

n,k = list(map(int, input().split()))
marks = list(map(int, input().split()))
i = 0
j = i+k
while j<n:
    if marks[j]>marks[i]:
        print("Yes")
    else:
        print("No")
    i+=1
    j+=1
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
#print(a)

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

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

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

s = 1
ps = 1
for i in range(n):
    s *= aa[i]
    if i >= k:
        s //= aa[i - k]
        if ps < s:
            print('Yes')
        else:
            print('No')
    ps = s


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

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

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

for i in range(0,N-K):
    print(('Yes' if 1<A[i+K]/A[i] else 'No'))
# Original solution
import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range;R=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def MI():return map(int,input().split())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RA():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in range(V)]
    FromStdin=True if ls==None else False
    for i in range(E):
        if FromStdin:
            inp=LI()
            org_inp.append(inp)
        else:
            inp=ls[i]
        if len(inp)==2:
            a,b=inp;c=1
        else:
            a,b,c=inp
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
    #h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
    mp=[boundary]*(w+2);found={}
    for i in R(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
    rt=[0]
    for i in ls:rt+=[rt[-1]+i]
    return rt
def bit_combination(n,base=2):
    rt=[]
    for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
    return rt
def gcd(x,y):
    if y==0:return x
    if x%y==0:return y
    while x%y!=0:x,y=y,x%y
    return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()

########################################################################################################################################################################

show_flg=False
show_flg=True

ans=0

n,k=LI()
a=LI()
for i in range(n-k):
    if a[i]<a[i+k]:
        Yn(1)
    else:
        Yn(0)


#show(n,m)



# Optimized solution
n,k,*a=list(map(int,open(0).read().split()))
for i in range(n-k):print(('YNeos'[a[i+k]<=a[i]::2]))
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
score = 1
for j in range(k):
    score *= a[j]

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


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