CodeEff/ECCO huggingface dataset:
# Original solution
N, K = [ int(v) for v in input().split(" ") ]
points = [ int(v) for v in input().split(" ") ]
tmp = None

results = []

for i in range(K, N+1):
  next_score = 1
  if tmp == None:
    for p in points[i-K:i]:
      next_score *= p
  else:
    next_score = tmp / points[i-K-1] * points[i-1]
  tmp = next_score
  results.append(next_score)

#print(results)

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

# Optimized solution
N, K = [ int(v) for v in input().split(" ") ]
points = [ int(v) for v in input().split(" ") ]

for i in range(K+1, N+1):
  if points[i-K-1] < points[i-1]:
    print("Yes")
  else:
    print("No")
# Original solution
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left, bisect_right #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

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

B = [0]*(N-K+1)
val = 1
for a in A[:K]:
    val *= a
B[0] = val
for i in range(1, N-K+1):
    B[i] = B[i-1]
    B[i] //= A[i-1]
    B[i] *= A[i+K-1]

for bi, bip in zip(B[:-1], B[1:]):
    if bi < bip:
        print('Yes')
    else:
        print('No')



# Optimized solution
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left, bisect_right #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

N, K = 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()))

t = 0
for i in range(n-k+1):
    t_2 = 0
    if i == 0:
        for j in range(k):
            t += a[j+i]
        continue
    for j in range(k):
        t_2 += a[j+i]
    if t_2>t:
        print("Yes")
    else:
        print("No")
    t = t_2


# 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 = list(map(int,input().split()))
a = list(map(int,input().split()))
ans = []
tmp = 1
#最初のK番目まで
for i in range(k):
  tmp *= a[i]
ans.append(tmp)
for j in range(k,n):
  tmp *= a[j]
  tmp //= a[j-k]
  ans.append(tmp)
for t in range(n-k):
  if ans[t+1] > ans[t]:
    print("Yes")
  else:
    print("No")

# Optimized solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
ans = []
for i in range(k,n):
  ans.append(a[i] - a[i-k])
for j in ans:
  if j > 0:
    print('Yes')
  else:
    print('No')
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

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

for i in range(k, n):
  total = tmp * a[i] / a[i - k]
  if total > tmp:
    print('Yes')
  else:
    print('No')
  tmp = total
  

# 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()))
P = 1

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

st = 0
la = K

for i in range(N-K):
    P2 = (P/A[st])*A[la]
    if P2 > P:
        print('Yes')
    else:
        print('No')
    st += 1
    la += 1
    P = P2

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

st = 0
la = K

for i in range(N-K):
    if A[la] > A[st]:
        print('Yes')
    else:
        print('No')
    st += 1
    la += 1
# Original solution
import itertools
import operator
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
cumpro = list(itertools.accumulate(a, func=operator.mul))
j = 0
for i in range(k,n):
    if j==0:
        last = cumpro[i-1]
        now = cumpro[i]//cumpro[j]
    else:
        now,last = cumpro[i]//cumpro[j],now
    print((['No','Yes'][last<now]))
    j+=1

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

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

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

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

# 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-k] < a[i]:
            #print(a[i])
            print('Yes')
        else:
            print('No')
# Original solution
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))

b = 1
for j in range(K):
    b *= A[j]

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




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

for i in range(1, N-K+1):
    print(('Yes' if A[i - 1] < A[i+K - 1] else 'No'))
# Original solution
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array

# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N, K = il()
    A = il()

    ret = [1] * N
    ret[0] = A[0]
    for n in range(1, N):
        ret[n] *= A[n] * ret[n - 1]
        if n >= K:
            ret[n] //= A[n - K]

    for k in range(K, N):
        if ret[k - 1] < ret[k]:
            print('Yes')
        else:
            print('No')


if __name__ == '__main__':
    main()


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

# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N, K = il()
    A = il()

    tmp = 0
    for k in range(K, N + 1):
        ret = 1
        for a in A[k - K:k]:
            ret *= a

        if tmp != 0 and tmp < ret:
            print('Yes')
        elif tmp != 0 and tmp >= ret:
            print('No')

        tmp = ret


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

for i in range(k,n):
    thescore=a[i]
    lastsemester=a[i-1]
    for j in range(1,k):
        thescore*=a[i-j]
        lastsemester*=a[i-1-j]
    if thescore>lastsemester:
        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 collections import deque
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
product = 1
for i in range(k):
    product *= l[i]

que = deque(l[:k])
for i in range(n-k):
    previous = product
    product //= que.popleft()
    product *= l[k+i]
    if product <= previous:
        print('No')
    else:
        print('Yes')
    que.append(l[k+i])

# Optimized solution
from collections import deque
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))

que = deque(l[:k])
for i in range(n-k):
    p = que.popleft()
    que.append(l[k+i])
    if p < l[k+i]:
        print('Yes')
    else:
        print('No')
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = [1] * (n - k + 1)
for i in range(k):
    s[0] *= a[i]
for i in range(1, n - k + 1):
    s[i] = int(s[i - 1] / a[i - 1] * a[k + i - 1])
for i in range(n - k):
    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(1, n - k + 1):
    print(('Yes' if 1 < a[k + i - 1] / a[i - 1] else 'No'))
# Original solution
N , K = list(map(int, input().split()))
A = list(map(int, input().split()))

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

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

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

for i in range(n - k + 1):
    score = 1
    for j in range(k):
        score *= a_list[i + j]
    if i != 0:
        if prev < score:
            print("Yes")
        else:
            print("No")
    prev = score


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

for i in range(n - k):
    if a_list[i] < a_list[i + k]:
        print("Yes")
    else:
        print("No")
# Original solution
N, K = list(map(int,input().split()))
 
A = list(map(int,input().split()))
 
for i in range(N - K):
  list_a = list(A[i:i+K])
  list_b = list(A[i+1:i+K+1])
  if list_a[0] < list_b[-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
def solve():
    N, K = list(map(int,input().split()))
    A = list(map(int,input().split()))

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

if __name__ == '__main__':
    solve()

# Optimized solution
def solve():
    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')

if __name__ == '__main__':
    solve()
# Original solution
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def SS(): return eval(input())
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

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

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

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

if __name__ == '__main__':
    resolve()


# Optimized solution
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def SS(): return eval(input())
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

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

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

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

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

ans = []
for i in range(k, n):
    mul *= a[i]
    mul //= a[i-k]
    if pre < mul:
        ans.append("Yes")
    else:
        ans.append("No")
    pre = mul
print(("\n".join(ans)))

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

ans = []
for i in range(k, n):
    if a[i-k] < a[i]:
        ans.append("Yes")
    else:
        ans.append("No")
print(("\n".join(ans)))
# Original solution
from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math
import string

def get_int():
    return int(stdin.readline().strip())


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


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

n,k = get_tuple()
ls = get_list()
i = 0
prod = 1
j = 0
start = ls[j]
while i<k:
    prod *= ls[i]
    i += 1

while i<n:
    oldprod = prod
    prod = int(prod/ls[j])
    prod *= ls[i]
    if oldprod>=prod:
        print("No")
    else:
        print("Yes")

    i += 1
    j += 1



# Optimized solution
from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math
import string

def get_int():
    return int(stdin.readline().strip())


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


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

n,k = get_tuple()
ls = get_list()
j = 0
i = k
while i<n:
    if ls[j]>=ls[i]:
        print("No")
    else:
        print("Yes")
    i += 1
    j += 1
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
r = 1
pre = 0
for i, a in enumerate(A):
    i += 1
    if i > K:
        r = r // A[i-K-1]
    r *= a
    if i > K:
        print(("Yes" if r > pre else "No"))
    pre = r

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

previous_score = 1

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

for j in range(k, n):
    score = previous_score * a[j] / a[j-k]

    if previous_score < score:
        print('Yes')
    else:
        print('No')

    previous_score = score

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

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


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

for i in range(N):
    if i>= K:
        prev = A[i-K] 
        cur = A[i]
        if prev >= cur:
            print('No')
        else :
            print('Yes')
# Original solution
def main():
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))
    sums = []
    amount = 1
    for i in range(0, k):
        amount = amount * a[i]
    sums.append(amount)

    for i in range(1, n-k+1):
        sums.append(sums[i-1]/a[i-1]*a[i+k-1])
        if sums[i-1] < sums[i]:
            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(0, n-k):
        if a[i] < a[k+i]:
            print("Yes")
        else:
            print("No")


if __name__ == '__main__':
    main()
# Original solution
import sys, math, itertools, collections, bisect 
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8') 
inf = float('inf') ;mod = 10**9+7 
mans = inf ;ans = 0 ;count = 0 ;pro = 1

import sys, math, itertools, collections, bisect 
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8') 
inf = float('inf') ;mod = 10**9+7 
mans = inf ;ans = 0 ;count = 0 ;pro = 1
 
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(k-1, n):
    if i == k-1:
        continue
    else:
        if A[i] > A[i-k]:
            print("Yes")
        else:
            print("No")
        #print(A[i], A[i-k])

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

dictS={}
dictS[0]=1

for n in range (1,N):
    if n<K:
        # S.append(A[n]*S[-1])
        dictS[n]=A[n]*dictS[n-1]
    else:
        # S.append(A[n]*S[-1]/A[n-K])
        dictS[n]=A[n]*dictS[n-1]/A[n-K]

    if n>=K:
        if dictS[n]>dictS[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):
    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()))

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

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

# 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 = [int(i) for i in input().split()]
s = 1
for i in range(k): s *= a[i]
for i in range(k,n):
    tmp = s
    s //= a[i-k]
    s *= a[i]
    if tmp < s: ans = "Yes"
    else: ans = "No"
    print(ans)

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

num_list = []

for i in range(n-k+1):
    num = 1
    for j in range(i,i+k):
        num *= a[j]
    num_list.append(num)
    
for i in range(len(num_list)-1):
    if num_list[i] < num_list[i+1]:
        print("Yes")
    else:
        print("No")

# Optimized solution
#c
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 = [0] * (N-K+1)

for i in range(K,N+1):
  if i == K:
    Hyoten[i-K] = 1
    for j in range(i-K,i):
      Hyoten[i-K] *= A[j]
  else:
    s_val = A[i-K-1]
    Hyoten[i-K] = Hyoten[i-K-1] / s_val * A[i-1]
    
for i in range(0,N-K+1):
  if i == 0:
    pre_Hyoten = Hyoten[i]
  else:
    if pre_Hyoten < Hyoten[i]:
      print("Yes")
    else:
      print("No")
      
    pre_Hyoten = Hyoten[i]



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

points = []

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

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

for p,n in zip(points, points[1:]):
    if p < n:
        print('Yes')
    else:
        print('No')

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

for p,n in zip(a, a[k:]):
    if p < n:
        print('Yes')
    else:
        print('No')
# Original solution
N, K = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a2 = [1]

for i in a:a2.append(a2[-1]*i)


score_dict = {K:a2[K]}

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

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

K_value = 1
for i in range(K):
    K_value *= a[i]
    
score_dict = {K-1:K_value}

for i in range(K, N):
    score_dict[i] = (score_dict[i-1] * a[i]) // a[i-K]
    if score_dict[i] > score_dict[i-1]:
        print('Yes')
    else:
        print('No')
# Original solution
N, K = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]

K_value = 1
for i in range(K):
    K_value *= a[i]
    
score_dict = {K-1:K_value}

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



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

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