CodeEff/ECCO huggingface dataset:
# Original solution
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
lst=[1]*n
for i in range(n):
  if i==0:
    lst[i]=A[i]
  elif 1<=i<=k-1:
    lst[i]=lst[i-1]*A[i]
  else:
    temp=lst[i-1]//A[i-k]
    lst[i]=temp*A[i]
    print(("Yes" if lst[i]>lst[i-1] else "No"))

# Optimized solution
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
lst=[1]*(n-k+1)
for i in range(n-k+1):
  if i==0:
    temp=1
    for j in range(k):
      temp*=A[j]
    lst[i]=temp
  else:
    temp=lst[i-1]//A[i-1]
    lst[i]=temp*A[i+k-1]
    print(("Yes" if lst[i]>lst[i-1] else "No"))
# Original solution
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(n-k+1):
  if i==0:
    temp=1
    for j in range(k):
      if A[j]!=1:
        temp*=A[j]
  else:
    newtemp=temp*A[i+k-1]//A[i-1]
    print(("Yes" if newtemp>temp else "No"))
    temp=newtemp

# 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+k-1]>A[i-1] else "No"))
# Original solution
N, K = list(map(int, input().split()))

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

score = [0]*N
dq = []

score_now = 1
for i in range(0, K):
    score_now *= A[i]
left = A[0]
index = 0

for j in range(K-1, N-1):
    score[j] = score_now

    score_now /= left
    index += 1
    left = A[index]
    score_now *= A[j+1]
score[N-1] = score_now


for k in range(K, N):
    if score[k] > score[k-1]:
        print("Yes")
    else:
        print("No")


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

index = 0
left = A[index]

for i in range(K+1, N):

    if A[index] < A[i]:
        print("Yes")
    else:
        print("No")

    index += 1
# Original solution
from sys import stdin, stdout 
n,k=list(map(int,input().split()))
a=[int(o) for o in input().split()]
prod=1
for i in range(k):
    prod*=a[i]
for i in range(k,n):
    prev=prod
    prod//=a[i-k]
    prod*=a[i]
    if prod>prev: stdout.write("Yes\n")
    else: stdout.write("No\n")


# Optimized solution
from sys import stdin, stdout 
n,k=list(map(int,input().split()))
a=[int(o) for o in input().split()]
prod=1
for i in range(k,n):
    prev=a[i-k]
    if a[i]>prev: stdout.write("Yes\n")
    else: stdout.write("No\n")
# Original solution
N,K = list(map(int,input().split()))
A = list(map(int, input().split()))
temp_1 = 1 #今
temp_2 = 1 #昔

for i in range(N):
    if i==0:
        temp_1 *= A[i]
    elif i<=(K-1):
        temp_2 = temp_1
        temp_1 *= A[i]
    if i>(K-1):
        temp_2 = temp_1
        temp_1 /= A[i-K]
        temp_1 *= A[i]
        if temp_2<temp_1:
            print('Yes')
        else:
            print('No')

# Optimized solution
N,K = list(map(int,input().split()))
A = list(map(int, input().split()))
temp_1 = 1 #今
temp_2 = 1 #昔

for i in range(N):
    if i>(K-1):
        if A[i-K]<A[i]:
            print('Yes')
        else:
            print('No')
# Original solution
#!usr/bin/env python3
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


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


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    n, k = LI()
    a = LI()
    ans = [1]*n
    for i in range(k-1, n):
        for j in range(k):
            ans[i] *= a[i-j]
        if i > k-1:
            if i == 0 or ans[i] > ans[i-1]:
                print('Yes')
            else:
                print('No')
    return


# Solve
if __name__ == "__main__":
    solve()


# Optimized solution
#!usr/bin/env python3
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


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


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    n, k = LI()
    a = LI()
    for i in range(k, n):
        if a[i] > a[i-k]:
            print('Yes')
        else:
            print('No')
    return


# Solve
if __name__ == "__main__":
    solve()
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
X = 1
for i in range(K):
    X *= A[i]
Y = X
for i in range(K, N):
    X = X * A[i] // A[i-K]
    if Y < X:
        print("Yes")
    else:
        print("No")
    Y = X

# 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()))
 
seki_list = [0]*n
seki = 1
temp = 0

for i in range(n):
    seki *= A[i]
    seki_list[i] = seki

point = seki_list[k-1]

for i in range(k, n):
    temp = seki_list[i]/seki_list[i-k]
    if temp > point:
        print("Yes")
        point = temp
    else:
        print("No")
        point = temp

# 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(i) for i in input().split()]
A = [1]+[int(i) for i in input().split()]

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

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

c = N - K + 1
l = []

for i in range(K, N + 1):
    ans = 1
    for j in range(1, K + 1):
        ans *= A[i - j]
    l.append(ans)

for i in range(c - 1):
    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()))

c = N - K
l = []

for j in range(K, N):
        l.append(A[j - K])
        l.append(A[j])

L = len(l)
for i in range(0, L, 2):
    if l[i + 1] > l[i]:
        print("Yes")
    else:
        print("No")
# Original solution
N, K = list(map(int, input().split()))
A = [0] + list(map(int, input().split()))
score = [0]*(N+1)

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

for i in range(K+1, N+1):
    score[i] = score[i-1]*A[i]//A[i-K]
    print(('Yes' if score[i] > score[i-1] else '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):
    print(('Yes' if A[i] > A[i-K] else 'No'))
# Original solution
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)

def main():
    n,k = [int(i) for i in input().strip().split()]
    A = [int(i) for i in input().strip().split()] 
    cur_mul = [1] * n
    for i in range(n):
        if i == 0:
            cur_mul[i] = A[i]
        elif i > 0 and i <= k-1:
            cur_mul[i] = A[i] * cur_mul[i - 1]
        elif i > k-1:
            cur_mul[i] = cur_mul[i - 1] * A[i] // A[i - k]
            if cur_mul[i] > cur_mul[i - 1]:
                print("Yes")
            else:
                print("No")
    return

if __name__ == "__main__":
    main()


# Optimized solution
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)

def main():
    n,k = [int(i) for i in input().strip().split()]
    A = [int(i) for i in input().strip().split()] 

    for i in range(k, n):
        if A[i] > A[i - k]:
            print("Yes")
        
        else:
            print("No")
    return

if __name__ == "__main__":
    main()
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
ans = [1]*n
for i in range(k):
    ans[0] *= a[i]
for i in range(n-k):
    ans[i+1] = ans[i] * a[i+k] // a[i]
    if ans[i+1] > ans[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 = list(map(int, input().split()))
Ai = list(map(int, input().split()))

class SegTree:
    def __init__(self, init_val, f=lambda x,y : x*y, default=1):
        size = len(init_val)
        self.size = 2**(size-1).bit_length()
        self.default = default
        self.dat = [default]*(self.size*2)
        self.f = f

        for i in range(size):
            self.dat[self.size + i] = init_val[i]
        for i in range(self.size- 1, 0, -1):
            self.dat[i] = self.f(self.dat[2 * i], self.dat[2 * i + 1])

    def update(self, i, x):
        i += self.size
        self.dat[i] = x
        while i > 0:
            i >>= 1
            self.dat[i] = self.f(self.dat[i*2], self.dat[i*2+1])

    def query(self, l, r):
        l += self.size
        r += self.size
        lres, rres = self.default, self.default
        while l < r:
            if l & 1:
                lres = self.f(lres, self.dat[l])
                l += 1

            if r & 1:
                r -= 1
                rres = self.f(self.dat[r], rres)
            l >>= 1
            r >>= 1
        res = self.f(lres, rres)
        return res

seg = SegTree(Ai)
# print(seg.query(0, 1))

def score(i):
    return seg.query(i - K, i)

for i in range(K + 1, N + 1):
    sp = score(i - 1)
    s = score(i)

    if sp < s:
        print("Yes")
    else:
        print("No")


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

# class SegTree:
#     def __init__(self, init_val, f=lambda x,y : x*y, default=1):
#         size = len(init_val)
#         self.size = 2**(size-1).bit_length()
#         self.default = default
#         self.dat = [default]*(self.size*2)
#         self.f = f
#
#         for i in range(size):
#             self.dat[self.size + i] = init_val[i]
#         for i in range(self.size- 1, 0, -1):
#             self.dat[i] = self.f(self.dat[2 * i], self.dat[2 * i + 1])
#
#     def update(self, i, x):
#         i += self.size
#         self.dat[i] = x
#         while i > 0:
#             i >>= 1
#             self.dat[i] = self.f(self.dat[i*2], self.dat[i*2+1])
#
#     def query(self, l, r):
#         l += self.size
#         r += self.size
#         lres, rres = self.default, self.default
#         while l < r:
#             if l & 1:
#                 lres = self.f(lres, self.dat[l])
#                 l += 1
#
#             if r & 1:
#                 r -= 1
#                 rres = self.f(self.dat[r], rres)
#             l >>= 1
#             r >>= 1
#         res = self.f(lres, rres)
#         return res
#
# seg = SegTree(Ai)
# print(seg.query(0, 1))

# def score(i):
#     return seg.query(i - K, i)

for i in range(K + 1, N + 1):
    # sp = score(i - 1)
    # s = score(i)

    sp = Ai[i - K - 1]
    s = Ai[i - 1]

    if sp < s:
        print("Yes")
    else:
        print("No")
# Original solution
from sys import stdin
N,K = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) for x in stdin.readline().rstrip().split()]

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

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

# Optimized solution
from sys import stdin
N,K = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) for x in stdin.readline().rstrip().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()))

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

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

for i in range(n-k):
  if ans_list[i] < ans_list[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
n,k = list(map(int,input().split()))

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

evaluation = 1

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

for i in range(k, n+1):
    if i == n:
        break
    #print(a[i], a[i-k])
    next_evaluation = a[i]*evaluation//a[i-k]
    if evaluation < next_evaluation:
        print('Yes')
    else:
        print('No')
    evaluation = next_evaluation

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

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


for i in range(k, n+1):
    if i == n:
        break
    #print(a[i], a[i-k])
    if a[i-k] < a[i]:
        print('Yes')
    else:
        print('No')
# Original solution
from functools import reduce

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

mul = int(reduce(lambda x, y: x * y, A[:K]))

res = [mul]

for i in range(K, N):
    res.append(res[-1]*A[i]//A[i-K])
    print(('Yes' if res[-2] < res[-1] else 'No'))


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

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

def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

N,K = LI()
A = LI()

hyoten = [1] * (N-K+1)

for i in range(N-K+1):
    for q in range(K):
        hyoten[i] *= A[i+q]


for j in range(len(hyoten)-1):
    if (hyoten[j+1]>hyoten[j]):
        print('Yes')
    else:
        print('No')

    

# Optimized solution
import sys

def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

N,K = LI()
A = LI()

# hyoten = [1] * (N-K+1)

# for i in range(N-K+1):
#     for q in range(K):
#         hyoten[i] *= A[i+q]


# for j in range(len(hyoten)-1):
#     if (hyoten[j+1]>hyoten[j]):
#         print('Yes')
#     else:
#         print('No')

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

# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
judge = 1
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()))
score_1=1
for i in range(k):
  score_1=score_1*a[i]
score_2=score_1*a[k]/a[0]
if score_1<score_2:
  print('Yes')
else:
  print('No')
for i in range(k+1,n):
  score_1=score_2
  score_2=score_2*a[i]/a[i-k]
  if score_1<score_2:
    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()))

p = 1
conta = int(k)

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

while conta <= n-1:
  next_p = p * a[conta] // a[conta-k]
  if next_p > p:
    print('Yes')
  else:
    print('No')
  conta += 1

# 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 INT():
    return int(eval(input()))

def MI():
    return list(map(int, input().split()))

def LI():
    return list(map(int, input().split()))

N, K = MI()
A = LI()
score = 1

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

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

# Optimized solution
def INT():
    return int(eval(input()))

def MI():
    return list(map(int, input().split()))

def LI():
    return list(map(int, input().split()))

N, K = MI()
A = LI()

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

hyoten_i = 1
for i, a in enumerate(A):
  hyoten_prev = hyoten_i
  hyoten_i *= a
  if i + 1 > K:
    hyoten_i = hyoten_i / A[i - K]
    print(("Yes" if hyoten_i > hyoten_prev else "No"))

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

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


for j in range(n - k):
    if A[k + j] > A[j]:
        print("Yes")
    else:
        print("No")
    keep = keep * A[k + j] / A[j]


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

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

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


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):
        if A[i+K] > A[i]:
            print('Yes')
        else:
            print('No')


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


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

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


# Optimized solution
n, k = list(map(int, input().split()))
a = [int(_) for _ in input().split()]
bef = 0
for i in range(k, n):
    val = a[i]
    bef = a[i-k]
    if val > bef:
        print('Yes')
    else:
        print('No')
    bef = val
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
s=[1]
for i in range(n):
  s.append(s[-1]*a[i])
for i in range(k+1,n+1):
  if s[i]/s[i-k]>s[i-1]/s[i-1-k]:
    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]>1:
    print('Yes')
  else:
    print('No')
# Original solution
N,K = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
before = 1
for i in range(K):
    before *= A[i]
val = 0
for i in range(K,len(A)):
    val = before
    val = val / A[i-K] * A[i]

    if(val > before):
        print("Yes")
    else:
        print("No")
    before = val

# Optimized solution
N,K = [int(x) for x in input().split()]
A = [int(x) for x in 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()))
T = list(map(int,input().split()))
Number = []
for j in range(N-K+1):
    Num=1
    for i in range(K):
        Num *=T[i+j]
    Number.append(Num)

for p in range(N-K):
    if Number[p+1] - Number[p] >0:
        print('Yes')
    else:
        print('No')

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

ans = []
val = 1
for i in range(K-1):
    val *= A[i]
for i in range(K-1,N):
    if i==K-1:
        val *= A[i]
        continue
    if val<((val//A[i-K])*A[i]):
        ans.append("Yes")
    else:
        ans.append("No")
    val = val//A[i-K]
    val *= A[i]

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(K,N):
    if (A[i]/A[i-K])>1:
        ans.append("Yes")
    else:
        ans.append("No")

for i in range(len(ans)):
    print((ans[i]))
# Original solution
n, k = list(map(int,input().split()))
a = list(map(int,input().split()))
a1 = 1
a2 = 1

for i in range(n):
    if i < k:
        a1 = a1*a[i]
    else:
        a2 = a1
        a1 = a[i]*a1//a[i-k]
        if a1 > a2:
            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:
        continue
    else:
        if a[i-k] < a[i]:
            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()))

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